#!/usr/bin/python
# -*- coding: GBK -*-
#×÷Õß : 

import CommFunc
import binascii
import copy
from struct import *
from ctypes import *
#²å¼þÍ·
# 
#
ChNetPackDict={}
class  BString:
    NameLen = 0        # (BYTE NameLen )
    Name = ""        # (String Name )     //size = NameLen
    data = None

    def __init__(self):
        self.Clear()

        return
    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()

        self.NameLen, _pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name, _pos = CommFunc.ReadString(_lpData, _pos, self.NameLen)

        return _pos

    def Clear(self):
        self.NameLen = 0
        self.Name = ""
        return

    def GetLength(self):
        length = 0
        length += 1
        length += self.Name.Length();
        return  length;

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        return data

    def OutputString(self):
        DumpString = ''':
                            NameLen:%d,
                            Name:%s
                            '''\
                            %(
                            self.NameLen,
                            self.Name
                            )

        return  DumpString

class  tagHead:
    Cmd = 0     # (BYTE Cmd )
    SubCmd = 0      # (BYTE SubCmd )
    def __init__(self):
        self.Clear()

        return
    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()

        self.Cmd, _pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SubCmd, _pos = CommFunc.ReadBYTE(_lpData, _pos)

        return _pos

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

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        return  length;

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Cmd)
        data = CommFunc.WriteBYTE(data, self.SubCmd)
        return data

    def OutputString(self):
        DumpString = ''':
                            Cmd:%d,
                            SubCmd:%d
                            '''\
                            %(
                            self.Cmd,
                            self.SubCmd
                            )

        return  DumpString
#------------------------------------------------------
#A0 01 Gm¹ã²¥ÏûÏ¢#tagBroadCastInfo

class  tagBroadCastInfo(Structure):
    Head = tagHead()
    StartTime = 0    #(DWORD StartTime)
    EndTime = 0    #(DWORD EndTime)
    Interval = 0    #(WORD Interval)//ʱ¼ä¼ä¸ô
    MsgLen = 0    #(WORD MsgLen)
    Msg = ""    #(String Msg)//size = MsgLen
    IsDelOthers = 0    #(BYTE IsDelOthers)//ÊÇ·ñɾ³ýÆäËûµÄ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Interval,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MsgLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Msg,_pos = CommFunc.ReadString(_lpData, _pos,self.MsgLen)
        self.IsDelOthers,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA0
        self.Head.SubCmd = 0x01
        self.StartTime = 0
        self.EndTime = 0
        self.Interval = 0
        self.MsgLen = 0
        self.Msg = ""
        self.IsDelOthers = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.StartTime)
        data = CommFunc.WriteDWORD(data, self.EndTime)
        data = CommFunc.WriteWORD(data, self.Interval)
        data = CommFunc.WriteWORD(data, self.MsgLen)
        data = CommFunc.WriteString(data, self.MsgLen, self.Msg)
        data = CommFunc.WriteBYTE(data, self.IsDelOthers)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartTime:%d,
                                EndTime:%d,
                                Interval:%d,
                                MsgLen:%d,
                                Msg:%s,
                                IsDelOthers:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartTime,
                                self.EndTime,
                                self.Interval,
                                self.MsgLen,
                                self.Msg,
                                self.IsDelOthers
                                )
        return DumpString


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


#------------------------------------------------------
# A0 07 ¸±±¾µØͼ¹¦ÄÜÏß·ÈËÊý #tagGCFBLinePlayerCnt

class  tagGCFBLineInfo(Structure):
    FBLineID = 0    #(BYTE FBLineID)// ¹¦ÄÜÏß·ID
    PlayerCnt = 0    #(WORD PlayerCnt)// Ïß·µ±Ç°Íæ¼ÒÊý
    ExtraStrLen = 0    #(WORD ExtraStrLen)// ³¤¶È
    ExtraStr = ""    #(String ExtraStr)// ¶îÍâÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.FBLineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExtraStrLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExtraStr,_pos = CommFunc.ReadString(_lpData, _pos,self.ExtraStrLen)
        return _pos

    def Clear(self):
        self.FBLineID = 0
        self.PlayerCnt = 0
        self.ExtraStrLen = 0
        self.ExtraStr = ""
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 2
        length += len(self.ExtraStr)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.FBLineID)
        data = CommFunc.WriteWORD(data, self.PlayerCnt)
        data = CommFunc.WriteWORD(data, self.ExtraStrLen)
        data = CommFunc.WriteString(data, self.ExtraStrLen, self.ExtraStr)
        return data

    def OutputString(self):
        DumpString = '''
                                FBLineID:%d,
                                PlayerCnt:%d,
                                ExtraStrLen:%d,
                                ExtraStr:%s
                                '''\
                                %(
                                self.FBLineID,
                                self.PlayerCnt,
                                self.ExtraStrLen,
                                self.ExtraStr
                                )
        return DumpString


class  tagGCFBLinePlayerCnt(Structure):
    Head = tagHead()
    MapID = 0    #(DWORD MapID)// µØͼID
    Count = 0    #(BYTE Count)
    FBLineInfoList = list()    #(vector<tagGCFBLineInfo> FBLineInfoList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temFBLineInfoList = tagGCFBLineInfo()
            _pos = temFBLineInfoList.ReadData(_lpData, _pos)
            self.FBLineInfoList.append(temFBLineInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA0
        self.Head.SubCmd = 0x07
        self.MapID = 0
        self.Count = 0
        self.FBLineInfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#A0 05 ͬ²½¿ª·þÌìÊý #tagOpenServerDay

class  tagOpenServerDay(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Day", c_ushort),    # ÒÑ¿ª·þÌìÊý£¬´Ó0¿ªÊ¼
                  ("IsMixServer", c_ubyte),    #ÊÇ·ñÊǺϷþ·þÎñÆ÷
                  ("MixDay", c_ushort),    # ÒѺϷþÌìÊý£¬´Ó0¿ªÊ¼
                  ("OpenWeekday", c_ubyte),    #¿ª·þÊÇÖܼ¸£¬1´ú±íÖÜÒ»
                  ("NowYear", c_ushort),    #·þÎñÆ÷µ±Ç°Ê±¼ä - Äê
                  ("NowMonth", c_ubyte),    
                  ("NowDay", c_ubyte),    
                  ("NowHour", c_ubyte),    
                  ("NowMinute", c_ubyte),    
                  ("NowSecond", c_ubyte),    
                  ("NowMicSecond", c_int),    
                  ("WeekOfYear", c_ubyte),    #Ò»ÄêÖеĵڼ¸ÖÜ
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA0
        self.SubCmd = 0x05
        self.Day = 0
        self.IsMixServer = 0
        self.MixDay = 0
        self.OpenWeekday = 0
        self.NowYear = 0
        self.NowMonth = 0
        self.NowDay = 0
        self.NowHour = 0
        self.NowMinute = 0
        self.NowSecond = 0
        self.NowMicSecond = 0
        self.WeekOfYear = 0
        return

    def GetLength(self):
        return sizeof(tagOpenServerDay)

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

    def OutputString(self):
        DumpString = '''//A0 05 ͬ²½¿ª·þÌìÊý //tagOpenServerDay:
                                Cmd:%s,
                                SubCmd:%s,
                                Day:%d,
                                IsMixServer:%d,
                                MixDay:%d,
                                OpenWeekday:%d,
                                NowYear:%d,
                                NowMonth:%d,
                                NowDay:%d,
                                NowHour:%d,
                                NowMinute:%d,
                                NowSecond:%d,
                                NowMicSecond:%d,
                                WeekOfYear:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Day,
                                self.IsMixServer,
                                self.MixDay,
                                self.OpenWeekday,
                                self.NowYear,
                                self.NowMonth,
                                self.NowDay,
                                self.NowHour,
                                self.NowMinute,
                                self.NowSecond,
                                self.NowMicSecond,
                                self.WeekOfYear
                                )
        return DumpString


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


#------------------------------------------------------
# A0 08 Íæ¼Ò¼Ç¼ÐÅÏ¢ #tagGCPlayerRecInfo

class  tagGCPlayerRec(Structure):
    Time = 0    #(DWORD Time)//ʱ¼ä
    Value1 = 0    #(DWORD Value1)//Öµ1
    Value2 = 0    #(DWORD Value2)//Öµ2
    Value3 = 0    #(DWORD Value3)//Öµ3
    Value4 = 0    #(DWORD Value4)//Öµ4
    Value5 = 0    #(DWORD Value5)//Öµ5
    Value6 = 0    #(DWORD Value6)//Öµ6
    Value7 = 0    #(DWORD Value7)//Öµ7
    Value8 = 0    #(DWORD Value8)//Öµ8
    UserDataLen = 0    #(WORD UserDataLen)//À©Õ¹Êý¾Ý³¤¶È
    UserData = ""    #(String UserData)//À©Õ¹Êý¾Ý
    data = None

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

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

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

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

        return length

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

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


class  tagGCPlayerRecInfo(Structure):
    Head = tagHead()
    Type = 0    #(BYTE Type)//ÀàÐÍ
    Count = 0    #(WORD Count)//ÊýÁ¿
    PlayerRecList = list()    #(vector<tagGCPlayerRec> PlayerRecList)
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A0 06 ·þÎñÆ÷µØͼÏß·ÈËÊý״̬ #tagGCPyServerMapState

class  tagGCPyServerMapLineState(Structure):
    MapID = 0    #(DWORD MapID)// µØͼID
    LineCnt = 0    #(BYTE LineCnt)// Ïß·Êý
    LineCurPlayerCntList = list()    #(vector<DWORD> LineCurPlayerCntList)// Ïß·µ±Ç°Íæ¼ÒÊýÁбí
    LineMaxPlayerCntList = list()    #(vector<DWORD> LineMaxPlayerCntList)// Ïß·×î´óÍæ¼ÒÊýÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.LineCnt):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.LineCurPlayerCntList.append(value)
        for i in range(self.LineCnt):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.LineMaxPlayerCntList.append(value)
        return _pos

    def Clear(self):
        self.MapID = 0
        self.LineCnt = 0
        self.LineCurPlayerCntList = list()
        self.LineMaxPlayerCntList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteBYTE(data, self.LineCnt)
        for i in range(self.LineCnt):
            data = CommFunc.WriteDWORD(data, self.LineCurPlayerCntList[i])
        for i in range(self.LineCnt):
            data = CommFunc.WriteDWORD(data, self.LineMaxPlayerCntList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                MapID:%d,
                                LineCnt:%d,
                                LineCurPlayerCntList:%s,
                                LineMaxPlayerCntList:%s
                                '''\
                                %(
                                self.MapID,
                                self.LineCnt,
                                "...",
                                "..."
                                )
        return DumpString


class  tagGCPyServerMapState(Structure):
    Head = tagHead()
    MapCount = 0    #(BYTE MapCount)
    MapStateList = list()    #(vector<tagGCPyServerMapLineState> MapStateList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MapCount):
            temMapStateList = tagGCPyServerMapLineState()
            _pos = temMapStateList.ReadData(_lpData, _pos)
            self.MapStateList.append(temMapStateList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA0
        self.Head.SubCmd = 0x06
        self.MapCount = 0
        self.MapStateList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#A0 04 ͬ²½¿Í»§¶Ëʱ¼ä #tagServerDateTime

class  tagServerDateTime(Structure):
    Head = tagHead()
    Year = 0    #(WORD Year)
    Month = 0    #(BYTE Month)
    Day = 0    #(BYTE Day)
    Hour = 0    #(BYTE Hour)
    Minute = 0    #(BYTE Minute)
    Second = 0    #(BYTE Second)
    MicSecond = 0    #(DWORD MicSecond)
    CrossServerTime = ""    #(char CrossServerTime[19])
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Year,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Month,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Day,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Hour,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Minute,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Second,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MicSecond,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CrossServerTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA0
        self.Head.SubCmd = 0x04
        self.Year = 0
        self.Month = 0
        self.Day = 0
        self.Hour = 0
        self.Minute = 0
        self.Second = 0
        self.MicSecond = 0
        self.CrossServerTime = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Year)
        data = CommFunc.WriteBYTE(data, self.Month)
        data = CommFunc.WriteBYTE(data, self.Day)
        data = CommFunc.WriteBYTE(data, self.Hour)
        data = CommFunc.WriteBYTE(data, self.Minute)
        data = CommFunc.WriteBYTE(data, self.Second)
        data = CommFunc.WriteDWORD(data, self.MicSecond)
        data = CommFunc.WriteString(data, 19, self.CrossServerTime)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Year:%d,
                                Month:%d,
                                Day:%d,
                                Hour:%d,
                                Minute:%d,
                                Second:%d,
                                MicSecond:%d,
                                CrossServerTime:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Year,
                                self.Month,
                                self.Day,
                                self.Hour,
                                self.Minute,
                                self.Second,
                                self.MicSecond,
                                self.CrossServerTime
                                )
        return DumpString


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


#------------------------------------------------------
#A0 02 È«·þGMÓʼþ·¢ËÍ#tagServerGmMailInfo

class  tagServerGmMailInfo(Structure):
    Head = tagHead()
    TitleLen = 0    #(WORD TitleLen)//±êÌâ
    Title = ""    #(String Title)
    ContentLen = 0    #(WORD ContentLen)
    Content = ""    #(String Content)//size = ContentLen
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TitleLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Title,_pos = CommFunc.ReadString(_lpData, _pos,self.TitleLen)
        self.ContentLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Content,_pos = CommFunc.ReadString(_lpData, _pos,self.ContentLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA0
        self.Head.SubCmd = 0x02
        self.TitleLen = 0
        self.Title = ""
        self.ContentLen = 0
        self.Content = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += len(self.Title)
        length += 2
        length += len(self.Content)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.TitleLen)
        data = CommFunc.WriteString(data, self.TitleLen, self.Title)
        data = CommFunc.WriteWORD(data, self.ContentLen)
        data = CommFunc.WriteString(data, self.ContentLen, self.Content)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TitleLen:%d,
                                Title:%s,
                                ContentLen:%d,
                                Content:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TitleLen,
                                self.Title,
                                self.ContentLen,
                                self.Content
                                )
        return DumpString


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


#------------------------------------------------------
#A0 03 Íæ¼ÒÐÅϢͨÓüǼ #tagUniversalGameRecInfo

class  tagUniversalGameRec(Structure):
    Time = 0    #(DWORD Time)//ʱ¼ä
    StrValue1Len = 0    #(WORD StrValue1Len)//×Ö·û´®1³¤¶È
    StrValue1 = ""    #(String StrValue1)
    StrValue2Len = 0    #(WORD StrValue2Len)//×Ö·û´®2³¤¶È
    StrValue2 = ""    #(String StrValue2)
    StrValue3Len = 0    #(WORD StrValue3Len)//×Ö·û´®3³¤¶È
    StrValue3 = ""    #(String StrValue3)
    Value1 = 0    #(DWORD Value1)//ÊýÖµ1
    Value2 = 0    #(DWORD Value2)//ÊýÖµ1
    Value3 = 0    #(DWORD Value3)//ÊýÖµ1
    Value4 = 0    #(DWORD Value4)//ÊýÖµ1
    Value5 = 0    #(DWORD Value5)//ÊýÖµ1
    data = None

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

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

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

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

        return length

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

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


class  tagUniversalGameRecInfo(Structure):
    Head = tagHead()
    Type = 0    #(BYTE Type)//ÀàÐÍ
    Count = 0    #(WORD Count)//ÊýÁ¿
    UniversalGameRec = list()    #(vector<tagUniversalGameRec> UniversalGameRec)///size = Count	
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A4 0C ¶àÏÉÃËboss»î¶¯ÐÅÏ¢ #tagGCAllFamilyBossInfo

class  tagGCAllFamilyBossInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsEnd", c_ubyte),    # ÊÇ·ñÒѽáÊø
                  ]

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

    def GetLength(self):
        return sizeof(tagGCAllFamilyBossInfo)

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

    def OutputString(self):
        DumpString = '''// A4 0C ¶àÏÉÃËboss»î¶¯ÐÅÏ¢ //tagGCAllFamilyBossInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                IsEnd:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsEnd
                                )
        return DumpString


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


#------------------------------------------------------
# A4 11 ´«¹¦ÑûÇëÐÅÏ¢ #tagGCChuangongInviteInfo

class  tagGCChuangongInviteInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ·¢ÆðÑûÇëµÄÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// ·¢ÆðÑûÇëµÄÍæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x11
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x11
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


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


#------------------------------------------------------
# A4 12 ´«¹¦¿ªÊ¼ #tagGCChuangongStart

class  tagGCChuangongStart(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// Ò»Æð´«¹¦µÄÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x12
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x12
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        return

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

        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.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV
                                )
        return DumpString


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


#------------------------------------------------------
# A4 0A ¼ÙÏÉÃËÐÅÏ¢ #tagGCFakeFamilyInfo

class  tagGCFakeFamilyInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    FakeIDList = list()    #(vector<DWORD> FakeIDList)// ¼ÙÏÉÃËÃû×ÖË÷Òý1¿ªÊ¼
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x0A
        self.Count = 0
        self.FakeIDList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A4 03 ¼Ò×åÐÐΪÐÅÏ¢ #tagGCFamilyActionInfo

class  tagGCFamilyAction(Structure):
    Time = 0    #(DWORD Time)//ʱ¼ä
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)
    Value1 = 0    #(DWORD Value1)//ÊýÖµ1
    Value2 = 0    #(DWORD Value2)//ÊýÖµ2
    Value3 = 0    #(DWORD Value3)//ÊýÖµ3
    Value4 = 0    #(DWORD Value4)//ÊýÖµ4
    Value5 = 0    #(DWORD Value5)//ÊýÖµ5
    Value6 = 0    #(DWORD Value6)//ÊýÖµ6
    UseDataLen = 0    #(WORD UseDataLen)
    UseData = ""    #(String UseData)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UseDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UseData,_pos = CommFunc.ReadString(_lpData, _pos,self.UseDataLen)
        return _pos

    def Clear(self):
        self.Time = 0
        self.NameLen = 0
        self.Name = ""
        self.Value1 = 0
        self.Value2 = 0
        self.Value3 = 0
        self.Value4 = 0
        self.Value5 = 0
        self.Value6 = 0
        self.UseDataLen = 0
        self.UseData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Time)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        data = CommFunc.WriteDWORD(data, self.Value3)
        data = CommFunc.WriteDWORD(data, self.Value4)
        data = CommFunc.WriteDWORD(data, self.Value5)
        data = CommFunc.WriteDWORD(data, self.Value6)
        data = CommFunc.WriteWORD(data, self.UseDataLen)
        data = CommFunc.WriteString(data, self.UseDataLen, self.UseData)
        return data

    def OutputString(self):
        DumpString = '''
                                Time:%d,
                                NameLen:%d,
                                Name:%s,
                                Value1:%d,
                                Value2:%d,
                                Value3:%d,
                                Value4:%d,
                                Value5:%d,
                                Value6:%d,
                                UseDataLen:%d,
                                UseData:%s
                                '''\
                                %(
                                self.Time,
                                self.NameLen,
                                self.Name,
                                self.Value1,
                                self.Value2,
                                self.Value3,
                                self.Value4,
                                self.Value5,
                                self.Value6,
                                self.UseDataLen,
                                self.UseData
                                )
        return DumpString


class  tagGCFamilyActionInfo(Structure):
    Head = tagHead()
    FamilyID = 0    #(DWORD FamilyID)//¼Ò×åID
    ActionType = 0    #(BYTE ActionType)//ÀàÐÍ
    Count = 0    #(WORD Count)//ÊýÁ¿
    FamilyActionList = list()    #(vector<tagGCFamilyAction> FamilyActionList)//size = Count	
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x03
        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.ActionType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temFamilyActionList = tagGCFamilyAction()
            _pos = temFamilyActionList.ReadData(_lpData, _pos)
            self.FamilyActionList.append(temFamilyActionList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x03
        self.FamilyID = 0
        self.ActionType = 0
        self.Count = 0
        self.FamilyActionList = list()
        return

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

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


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


#------------------------------------------------------
# A4 0E ¼Ò×åboss¸±±¾ÐÅÏ¢ #tagGCFamilyBosFBInfo

class  tagGCFamilyBosFBInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("HurtTotal", c_int),    # ÏÉÃËÀÛ¼ÆÉËѪ£¬ÒÚÇóÓಿ·Ö
                  ("HurtTotalPoint", c_int),    # ÏÉÃËÀÛ¼ÆÉËѪ£¬ÒÚÕû³ý²¿·Ö
                  ("FightMemCount", c_ubyte),    # Ä¿Ç°ÕýÔÚÏÉÃËboss¸±±¾ÖеijÉÔ±Êý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA4
        self.SubCmd = 0x0E
        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 = 0xA4
        self.SubCmd = 0x0E
        self.HurtTotal = 0
        self.HurtTotalPoint = 0
        self.FightMemCount = 0
        return

    def GetLength(self):
        return sizeof(tagGCFamilyBosFBInfo)

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

    def OutputString(self):
        DumpString = '''// A4 0E ¼Ò×åboss¸±±¾ÐÅÏ¢ //tagGCFamilyBosFBInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                HurtTotal:%d,
                                HurtTotalPoint:%d,
                                FightMemCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.HurtTotal,
                                self.HurtTotalPoint,
                                self.FightMemCount
                                )
        return DumpString


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


#------------------------------------------------------
# A4 02 ¼Ò×åboss¸±±¾¿ªÆô¼°»÷ɱÐÅÏ¢ #tagGCFamilyBossFBInfo

class  tagGCFamilyBossFBInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsOpen", c_int),    # ÊÇ·ñÒÑ¿ªÆô
                  ("OpenCnt", c_ubyte),    # ±¾ÖÜÒÑ¿ªÆô´ÎÊý
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA4
        self.SubCmd = 0x02
        self.IsOpen = 0
        self.OpenCnt = 0
        return

    def GetLength(self):
        return sizeof(tagGCFamilyBossFBInfo)

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

    def OutputString(self):
        DumpString = '''// A4 02 ¼Ò×åboss¸±±¾¿ªÆô¼°»÷ɱÐÅÏ¢ //tagGCFamilyBossFBInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                IsOpen:%d,
                                OpenCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsOpen,
                                self.OpenCnt
                                )
        return DumpString


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


#------------------------------------------------------
# A4 05 ¼Ò×åºì°üÇÀµÄÐÅÏ¢ #tagGCFamilyRedPacketGrabInfo

class  tagFGrabRedPacketInfo(Structure):
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//Ãû×Ö
    PlayeJob = 0    #(BYTE PlayeJob)//Íæ¼ÒÖ°Òµ
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    MoneyNum = 0    #(DWORD MoneyNum)//½ðÇ®ÊýÁ¿
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.PlayeJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MoneyNum,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

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

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteBYTE(data, self.PlayeJob)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.MoneyNum)
        return data

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


class  tagGCFamilyRedPacketGrabInfo(Structure):
    Head = tagHead()
    RedPacketID = 0    #(DWORD RedPacketID)//ºì°üΨһID
    Count = 0    #(BYTE Count)//ÊýÁ¿
    GrabInfo = list()    #(vector<tagFGrabRedPacketInfo> GrabInfo)//size = Count
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A4 04 ¼Ò×åºì°ü×ÜÐÅÏ¢ #tagGCFamilyRedPacketInfo

class  tagFRedPacketInfo(Structure):
    RedPacketID = 0    #(DWORD RedPacketID)//ºì°üΨһID
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//Íæ¼ÒÃû×Ö
    Time = 0    #(DWORD Time)//ʱ¼ä
    PlayeJob = 0    #(BYTE PlayeJob)//Íæ¼ÒÖ°Òµ
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    MoneyType = 0    #(BYTE MoneyType)//½ðÇ®ÀàÐÍ
    MoneyNum = 0    #(DWORD MoneyNum)//½ðÇ®ÊýÁ¿
    GetWay = 0    #(BYTE GetWay)//»ñµÃ;¾¶
    PacketCnt = 0    #(BYTE PacketCnt)//¿ÉÇÀ¸öÊý
    State = 0    #(BYTE State)//0δ·¢,1δÁìÈ¡,2ÒÑÁìÈ¡,3È«²¿ÁìÍê
    WishLen = 0    #(BYTE WishLen)
    Wish = ""    #(String Wish)//×£¸£Óï
    IsAnonymous = 0    #(BYTE IsAnonymous)//ÊÇ·ñÄäÃû
    data = None

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

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

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

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

        return length

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

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


class  tagGCFamilyRedPacketInfo(Structure):
    Head = tagHead()
    IsAll = 0    #(BYTE IsAll)//ÊÇ·ñÈ«²¿ºì°ü
    Count = 0    #(BYTE Count)//ºì°üÊýÁ¿
    RedPacketInfo = list()    #(vector<tagFRedPacketInfo> RedPacketInfo)//size = Count
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A4 06 ¼Ò×å²Ö¿âÎïÆ·ÐÅÏ¢ #tagGCFamilyStoreItemInfo

class  tagGCFamilyStoreItem(Structure):
    Index = 0    #(BYTE Index)// ²Ö¿â¸ñ×ÓË÷Òý£¬´Ó0¿ªÊ¼´ú±íµÚÒ»¸ñ
    ItemID = 0    #(DWORD ItemID)// ÎïÆ·ID
    ItemDataLen = 0    #(WORD ItemDataLen)
    ItemData = ""    #(String ItemData)//size = ItemDataLen
    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.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataLen)
        return _pos

    def Clear(self):
        self.Index = 0
        self.ItemID = 0
        self.ItemDataLen = 0
        self.ItemData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Index)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemDataLen)
        data = CommFunc.WriteString(data, self.ItemDataLen, self.ItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Index:%d,
                                ItemID:%d,
                                ItemDataLen:%d,
                                ItemData:%s
                                '''\
                                %(
                                self.Index,
                                self.ItemID,
                                self.ItemDataLen,
                                self.ItemData
                                )
        return DumpString


class  tagGCFamilyStoreItemInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)//ÊýÁ¿
    StoreItemList = list()    #(vector<tagGCFamilyStoreItem> StoreItemList)//size = Count
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temStoreItemList = tagGCFamilyStoreItem()
            _pos = temStoreItemList.ReadData(_lpData, _pos)
            self.StoreItemList.append(temStoreItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x06
        self.Count = 0
        self.StoreItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A4 07 ¼Ò×å²Ö¿âÎïÆ·Çå³ý #tagGCFamilyStoreItemClear

class  tagGCFamilyStoreItemClear(Structure):
    Head = tagHead()
    ClearType = 0    #(BYTE ClearType)//0-Ö¸¶¨¸ñ×ÓÇå³ý; 1-ËùÓÐÎïÆ·Çå³ý
    IndexCount = 0    #(BYTE IndexCount)
    IndexList = list()    #(vector<BYTE> IndexList)//Çå³ýµÄ¸ñ×ÓË÷Òý, ½öÖ¸¶¨¸ñ×ÓÇå³ýʱÓÐЧ,´Ó0¿ªÊ¼´ú±íµÚÒ»¸ñ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ClearType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IndexCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.IndexCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.IndexList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x07
        self.ClearType = 0
        self.IndexCount = 0
        self.IndexList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ClearType:%d,
                                IndexCount:%d,
                                IndexList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ClearType,
                                self.IndexCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# A4 09 ¼Ò×åÊØÎÀÈË»ÊÐÅϢ֪ͨ #tagGCFamilySWRHInfo

class  tagGCFamilySWRHInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("HasJoin", c_ubyte),    # ÊÇ·ñÒѲÎÓë
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA4
        self.SubCmd = 0x09
        self.HasJoin = 0
        return

    def GetLength(self):
        return sizeof(tagGCFamilySWRHInfo)

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

    def OutputString(self):
        DumpString = '''// A4 09 ¼Ò×åÊØÎÀÈË»ÊÐÅϢ֪ͨ //tagGCFamilySWRHInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                HasJoin:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.HasJoin
                                )
        return DumpString


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


#------------------------------------------------------
# A4 0B Íæ¼Ò²ÎÓëµÄÏÉÃËÁªÈüÏÉÃËÐÅÏ¢ #tagGCPlayerJoinFamilyWarInfo

class  tagGCPlayerJoinFamilyWarInfo(Structure):
    Head = tagHead()
    JoinFamilyID = 0    #(DWORD JoinFamilyID)//²ÎÓëµÄÏÉÃËID£¬Ä¬ÈÏ0±¾ÏÉÃË£¬ÏÉÃ˲»Í¬Ê±²Å»áÊÕµ½±¾°ü
    JoinFamilyNameLen = 0    #(BYTE JoinFamilyNameLen)
    JoinFamilyName = ""    #(String JoinFamilyName)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.JoinFamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.JoinFamilyNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JoinFamilyName,_pos = CommFunc.ReadString(_lpData, _pos,self.JoinFamilyNameLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x0B
        self.JoinFamilyID = 0
        self.JoinFamilyNameLen = 0
        self.JoinFamilyName = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.JoinFamilyID)
        data = CommFunc.WriteBYTE(data, self.JoinFamilyNameLen)
        data = CommFunc.WriteString(data, self.JoinFamilyNameLen, self.JoinFamilyName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                JoinFamilyID:%d,
                                JoinFamilyNameLen:%d,
                                JoinFamilyName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.JoinFamilyID,
                                self.JoinFamilyNameLen,
                                self.JoinFamilyName
                                )
        return DumpString


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


#------------------------------------------------------
# A4 08 ²é¿´¼Ò×å #tagGCPyAllFamilyView

class  tagGCPyFamilyView(Structure):
    FamilyIndex = 0    #(WORD FamilyIndex)
    FamilyID = 0    #(DWORD FamilyID)//¼Ò×åID
    FamilyNameLen = 0    #(BYTE FamilyNameLen)
    FamilyName = ""    #(String FamilyName)//size = FamilyNameLen
    LeaderID = 0    #(DWORD LeaderID)//×峤ID
    LeaderNameLen = 0    #(BYTE LeaderNameLen)
    LeaderName = ""    #(String LeaderName)//size = LeaderNameLen
    LeaderOfficialRank = 0    #(BYTE LeaderOfficialRank)//¾³½ç
    FamilyLV = 0    #(WORD FamilyLV)//¼Ò×åµÈ¼¶
    FamilyMemberCount = 0    #(WORD FamilyMemberCount)//¼Ò×åÈËÊý
    JoinAccept = 0    #(BYTE JoinAccept)//ÉêÇë״̬
    WarRank = 0    #(BYTE WarRank)//ÁªÈüÅÅÃû
    TotalFightPower = 0    #(DWORD TotalFightPower)//×ÜÕ½Á¦£¬²»×ã1¸öÒڵIJ¿·Ö
    TotalFightPowerEx = 0    #(DWORD TotalFightPowerEx)//×ÜÕ½Á¦µã£¬1µã=1ÒÚ
    EmblemID = 0    #(BYTE EmblemID)//»ÕÕÂID
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.FamilyIndex,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FamilyNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FamilyName,_pos = CommFunc.ReadString(_lpData, _pos,self.FamilyNameLen)
        self.LeaderID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LeaderNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LeaderName,_pos = CommFunc.ReadString(_lpData, _pos,self.LeaderNameLen)
        self.LeaderOfficialRank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FamilyLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FamilyMemberCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.JoinAccept,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WarRank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TotalFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EmblemID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.FamilyIndex = 0
        self.FamilyID = 0
        self.FamilyNameLen = 0
        self.FamilyName = ""
        self.LeaderID = 0
        self.LeaderNameLen = 0
        self.LeaderName = ""
        self.LeaderOfficialRank = 0
        self.FamilyLV = 0
        self.FamilyMemberCount = 0
        self.JoinAccept = 0
        self.WarRank = 0
        self.TotalFightPower = 0
        self.TotalFightPowerEx = 0
        self.EmblemID = 0
        return

    def GetLength(self):
        length = 0
        length += 2
        length += 4
        length += 1
        length += len(self.FamilyName)
        length += 4
        length += 1
        length += len(self.LeaderName)
        length += 1
        length += 2
        length += 2
        length += 1
        length += 1
        length += 4
        length += 4
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteWORD(data, self.FamilyIndex)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteBYTE(data, self.FamilyNameLen)
        data = CommFunc.WriteString(data, self.FamilyNameLen, self.FamilyName)
        data = CommFunc.WriteDWORD(data, self.LeaderID)
        data = CommFunc.WriteBYTE(data, self.LeaderNameLen)
        data = CommFunc.WriteString(data, self.LeaderNameLen, self.LeaderName)
        data = CommFunc.WriteBYTE(data, self.LeaderOfficialRank)
        data = CommFunc.WriteWORD(data, self.FamilyLV)
        data = CommFunc.WriteWORD(data, self.FamilyMemberCount)
        data = CommFunc.WriteBYTE(data, self.JoinAccept)
        data = CommFunc.WriteBYTE(data, self.WarRank)
        data = CommFunc.WriteDWORD(data, self.TotalFightPower)
        data = CommFunc.WriteDWORD(data, self.TotalFightPowerEx)
        data = CommFunc.WriteBYTE(data, self.EmblemID)
        return data

    def OutputString(self):
        DumpString = '''
                                FamilyIndex:%d,
                                FamilyID:%d,
                                FamilyNameLen:%d,
                                FamilyName:%s,
                                LeaderID:%d,
                                LeaderNameLen:%d,
                                LeaderName:%s,
                                LeaderOfficialRank:%d,
                                FamilyLV:%d,
                                FamilyMemberCount:%d,
                                JoinAccept:%d,
                                WarRank:%d,
                                TotalFightPower:%d,
                                TotalFightPowerEx:%d,
                                EmblemID:%d
                                '''\
                                %(
                                self.FamilyIndex,
                                self.FamilyID,
                                self.FamilyNameLen,
                                self.FamilyName,
                                self.LeaderID,
                                self.LeaderNameLen,
                                self.LeaderName,
                                self.LeaderOfficialRank,
                                self.FamilyLV,
                                self.FamilyMemberCount,
                                self.JoinAccept,
                                self.WarRank,
                                self.TotalFightPower,
                                self.TotalFightPowerEx,
                                self.EmblemID
                                )
        return DumpString


class  tagGCPyAllFamilyView(Structure):
    Head = tagHead()
    TotalCount = 0    #(DWORD TotalCount)//Ò»¹²ÓжàÉÙÒ³
    CurPage = 0    #(WORD CurPage)//µ±Ç°µÚ¼¸Ò³, ÿҳ¸öÊý:FAMILY_VIEW_PAGE_COUNT
    PageCount = 0    #(BYTE PageCount)//ÕâÒ»Ò³ÓжàÉÙÊýÄ¿
    Family = list()    #(vector<tagGCPyFamilyView> Family)//size = PageCount
    IsSearching = 0    #(BYTE IsSearching)//ÊÇ·ñÔÚÄ£ºýËÑË÷״̬ÏÂ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TotalCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CurPage,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PageCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PageCount):
            temFamily = tagGCPyFamilyView()
            _pos = temFamily.ReadData(_lpData, _pos)
            self.Family.append(temFamily)
        self.IsSearching,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x08
        self.TotalCount = 0
        self.CurPage = 0
        self.PageCount = 0
        self.Family = list()
        self.IsSearching = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.TotalCount)
        data = CommFunc.WriteWORD(data, self.CurPage)
        data = CommFunc.WriteBYTE(data, self.PageCount)
        for i in range(self.PageCount):
            data = CommFunc.WriteString(data, self.Family[i].GetLength(), self.Family[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsSearching)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TotalCount:%d,
                                CurPage:%d,
                                PageCount:%d,
                                Family:%s,
                                IsSearching:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TotalCount,
                                self.CurPage,
                                self.PageCount,
                                "...",
                                self.IsSearching
                                )
        return DumpString


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


#------------------------------------------------------
# A4 0D ֪ͨ½¨ÃË´ÎÊý #tagGCServerCreatFamilyTimes

class  tagGCServerCreatFamilyTimes(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Times", c_int),    #½¨ÃË´ÎÊý
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA4
        self.SubCmd = 0x0D
        self.Times = 0
        return

    def GetLength(self):
        return sizeof(tagGCServerCreatFamilyTimes)

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

    def OutputString(self):
        DumpString = '''// A4 0D ֪ͨ½¨ÃË´ÎÊý //tagGCServerCreatFamilyTimes:
                                Cmd:%s,
                                SubCmd:%s,
                                Times:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Times
                                )
        return DumpString


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


#------------------------------------------------------
#A4 01  ²é¿´ÉêÇëÈë»áµÄÍæ¼ÒÐÅÏ¢ #tagGCViewFamilyRequestInfo

class  tagtMemberInfo(Structure):
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    NameLen = 0    #(BYTE NameLen)//Ãû×Ö³¤¶È
    Name = ""    #(String Name)//size=NameLen
    PlayerLV = 0    #(WORD PlayerLV)//Íæ¼ÒµÈ¼¶
    PlayeJob = 0    #(BYTE PlayeJob)//Íæ¼ÒÖ°Òµ
    PlayeFightPower = 0    #(DWORD PlayeFightPower)//Íæ¼ÒÕ½¶·Á¦£¬ÇóÓàÒÚ²¿·Ö
    PlayeFightPowerEx = 0    #(DWORD PlayeFightPowerEx)//Íæ¼ÒÕ½¶·Á¦£¬Õû³ýÒÚ²¿·Ö£¬1´ú±í1ÒÚ
    RequestTime = 0    #(DWORD RequestTime)//ÉêÇëʱ¼ä
    IsOnLine = 0    #(BYTE IsOnLine)//ÊÇ·ñÔÚÏß
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.PlayerLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PlayeJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayeFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayeFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RequestTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsOnLine,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.PlayerLV = 0
        self.PlayeJob = 0
        self.PlayeFightPower = 0
        self.PlayeFightPowerEx = 0
        self.RequestTime = 0
        self.IsOnLine = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.PlayerLV)
        data = CommFunc.WriteBYTE(data, self.PlayeJob)
        data = CommFunc.WriteDWORD(data, self.PlayeFightPower)
        data = CommFunc.WriteDWORD(data, self.PlayeFightPowerEx)
        data = CommFunc.WriteDWORD(data, self.RequestTime)
        data = CommFunc.WriteBYTE(data, self.IsOnLine)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                PlayerLV:%d,
                                PlayeJob:%d,
                                PlayeFightPower:%d,
                                PlayeFightPowerEx:%d,
                                RequestTime:%d,
                                IsOnLine:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.PlayerLV,
                                self.PlayeJob,
                                self.PlayeFightPower,
                                self.PlayeFightPowerEx,
                                self.RequestTime,
                                self.IsOnLine
                                )
        return DumpString


class  tagGCViewFamilyRequestInfo(Structure):
    Head = tagHead()
    RequestMemberCount = 0    #(BYTE RequestMemberCount)//ÉêÇë³ÉÔ±µÄÊýÁ¿
    MemberInfo = list()    #(vector<tagtMemberInfo> MemberInfo)//size = RequestMemberCount
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RequestMemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RequestMemberCount):
            temMemberInfo = tagtMemberInfo()
            _pos = temMemberInfo.ReadData(_lpData, _pos)
            self.MemberInfo.append(temMemberInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA4
        self.Head.SubCmd = 0x01
        self.RequestMemberCount = 0
        self.MemberInfo = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 26 ¾º¼¼³¡¶ÔÕ½Íæ¼Ò×îÐÂÐÅÏ¢ #tagGCArenaBattlePlayerInfo

class  tagGCArenaBattlePlayerInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Ä¿±êÍæ¼ÒID
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç£¬»úÆ÷È˶Á¾³½ç±íÈ¡µÈ¼¶¶ÔÓ¦¾³½ç
    FightPower = 0    #(DWORD FightPower)//Õ½Á¦ÇóÓàÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    FightPowerEx = 0    #(DWORD FightPowerEx)//Õ½Á¦Õû³ýÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    Score = 0    #(DWORD Score)//»ý·Ö
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

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

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        data = CommFunc.WriteDWORD(data, self.Score)
        return data

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


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


#------------------------------------------------------
# A9 23 ¾º¼¼³¡¶ÔÕ½¼Ç¼Áбí #tagGCArenaBattleRecordList

class  tagGCArenaBattleRecord(Structure):
    PlayerID = 0    #(DWORD PlayerID)//Ä¿±êÍæ¼ÒID£¬Ð¡ÓÚ10000Ϊ»úÆ÷ÈËID
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç£¬»úÆ÷È˶Á¾³½ç±íÈ¡µÈ¼¶¶ÔÓ¦¾³½ç
    FightPower = 0    #(DWORD FightPower)//Õ½Á¦ÇóÓàÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    FightPowerEx = 0    #(DWORD FightPowerEx)//Õ½Á¦Õû³ýÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    Score = 0    #(DWORD Score)//»ý·Ö
    AddScoreLen = 0    #(BYTE AddScoreLen)
    AddScore = ""    #(String AddScore)//±¾´Î¶ÔÕ½Ôö¼ÓµÄ»ý·Ö£¬ÓÐÕý¸º
    IsWin = 0    #(BYTE IsWin)//ÊÇ·ñ»ñʤ
    Time = 0    #(DWORD Time)//ʱ¼ä´Á
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AddScoreLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AddScore,_pos = CommFunc.ReadString(_lpData, _pos,self.AddScoreLen)
        self.IsWin,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.Score = 0
        self.AddScoreLen = 0
        self.AddScore = ""
        self.IsWin = 0
        self.Time = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        data = CommFunc.WriteDWORD(data, self.Score)
        data = CommFunc.WriteBYTE(data, self.AddScoreLen)
        data = CommFunc.WriteString(data, self.AddScoreLen, self.AddScore)
        data = CommFunc.WriteBYTE(data, self.IsWin)
        data = CommFunc.WriteDWORD(data, self.Time)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCArenaBattleRecordList(Structure):
    Head = tagHead()
    RecordCount = 0    #(BYTE RecordCount)
    BattleRecordList = list()    #(vector<tagGCArenaBattleRecord> BattleRecordList)// ¶ÔÕ½Áбí
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A9 22 ¾º¼¼³¡Æ¥ÅäÍæ¼ÒÁбí #tagGCArenaMatchList

class  tagGCArenaMatchInfo(Structure):
    PlayerID = 0    #(DWORD PlayerID)//Ä¿±êÍæ¼ÒID£¬Ð¡ÓÚ10000Ϊ»úÆ÷ÈËID
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç£¬»úÆ÷È˶Á¾³½ç±íÈ¡µÈ¼¶¶ÔÓ¦¾³½ç
    FightPower = 0    #(DWORD FightPower)//Õ½Á¦ÇóÓàÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    FightPowerEx = 0    #(DWORD FightPowerEx)//Õ½Á¦Õû³ýÒÚ²¿·Ö£¬»úÆ÷È˶ÁµÈ¼¶±íÈ¡µÈ¼¶¶ÔÓ¦Õ½Á¦
    Score = 0    #(DWORD Score)//»ý·Ö
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.Score = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        data = CommFunc.WriteDWORD(data, self.Score)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCArenaMatchList(Structure):
    Head = tagHead()
    MatchCount = 0    #(BYTE MatchCount)
    MatchList = list()    #(vector<tagGCArenaMatchInfo> MatchList)// Æ¥ÅäÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MatchCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MatchCount):
            temMatchList = tagGCArenaMatchInfo()
            _pos = temMatchList.ReadData(_lpData, _pos)
            self.MatchList.append(temMatchList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x22
        self.MatchCount = 0
        self.MatchList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 09 ֪ͨBOSS¹Ø×¢¼Ç¼ #tagGCBossAttentionInfo

class  tagGCBossAttention(Structure):
    _pack_ = 1
    _fields_ = [
                  ("BossID", c_int),    # bossID
                  ("AddState", c_ubyte),    # ¹Øע״̬
                  ]

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

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

    def Clear(self):
        self.BossID = 0
        self.AddState = 0
        return

    def GetLength(self):
        return sizeof(tagGCBossAttention)

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

    def OutputString(self):
        DumpString = '''// A9 09 ֪ͨBOSS¹Ø×¢¼Ç¼ //tagGCBossAttentionInfo:
                                BossID:%d,
                                AddState:%d
                                '''\
                                %(
                                self.BossID,
                                self.AddState
                                )
        return DumpString


class  tagGCBossAttentionInfo(Structure):
    Head = tagHead()
    BossCnt = 0    #(BYTE BossCnt)//boss¸öÊý
    BossList = list()    #(vector<tagGCBossAttention> BossList)//Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.BossCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BossCnt):
            temBossList = tagGCBossAttention()
            _pos = temBossList.ReadData(_lpData, _pos)
            self.BossList.append(temBossList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x09
        self.BossCnt = 0
        self.BossList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 01 ÊÀ½çboss·ÖÁ÷Ïß·boss״̬ #tagGCBossShuntLineStateInfo

class  tagGCBossShuntLineState(Structure):
    BossID = 0    #(DWORD BossID)// bossID
    LineCount = 0    #(BYTE LineCount)
    LineIDList = list()    #(vector<BYTE> LineIDList)// Ïß·IDÁбí
    StateList = list()    #(vector<BYTE> StateList)// ¶ÔӦ״̬ÁÐ±í£¬ 0-±»»÷ɱ£¬1-»î×Å
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.BossID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.LineCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.LineIDList.append(value)
        for i in range(self.LineCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.StateList.append(value)
        return _pos

    def Clear(self):
        self.BossID = 0
        self.LineCount = 0
        self.LineIDList = list()
        self.StateList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.BossID)
        data = CommFunc.WriteBYTE(data, self.LineCount)
        for i in range(self.LineCount):
            data = CommFunc.WriteBYTE(data, self.LineIDList[i])
        for i in range(self.LineCount):
            data = CommFunc.WriteBYTE(data, self.StateList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                BossID:%d,
                                LineCount:%d,
                                LineIDList:%s,
                                StateList:%s
                                '''\
                                %(
                                self.BossID,
                                self.LineCount,
                                "...",
                                "..."
                                )
        return DumpString


class  tagGCBossShuntLineStateInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    BossLineStateInfo = list()    #(vector<tagGCBossShuntLineState> BossLineStateInfo)//boss·ÖÁ÷Ïß·ÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBossLineStateInfo = tagGCBossShuntLineState()
            _pos = temBossLineStateInfo.ReadData(_lpData, _pos)
            self.BossLineStateInfo.append(temBossLineStateInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x01
        self.Count = 0
        self.BossLineStateInfo = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 AC ½»Ò×ËùÎïÆ·×îгɽ»¼Û֪ͨ #tagGCBourseItemPrice

class  tagGCBourseItemPrice(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ItemID", c_int),    #ÎïÆ·ID
                  ("Price", c_int),    #×îгɽ»µ¥¼Û
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA9
        self.SubCmd = 0xAC
        self.ItemID = 0
        self.Price = 0
        return

    def GetLength(self):
        return sizeof(tagGCBourseItemPrice)

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

    def OutputString(self):
        DumpString = '''// A9 AC ½»Ò×ËùÎïÆ·×îгɽ»¼Û֪ͨ //tagGCBourseItemPrice:
                                Cmd:%s,
                                SubCmd:%s,
                                ItemID:%d,
                                Price:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ItemID,
                                self.Price
                                )
        return DumpString


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


#------------------------------------------------------
# A9 AB ½»Ò×Ëù½»Ò׼Ǽ֪ͨ #tagGCBourseRecordInfo

class  tagGCBourseRecord(Structure):
    Type = 0    #(BYTE Type)//ÀàÐÍ 0-¹ºÂò 1-Âô³ö
    Timestamp = 0    #(DWORD Timestamp)//ʱ¼ä´Á
    TradeTax = 0    #(DWORD TradeTax)//½»Ò×Ë°
    TradeMoney = 0    #(DWORD TradeMoney)//ÊÕÖ§
    ItemDataLen = 0    #(WORD ItemDataLen)
    ItemData = ""    #(String ItemData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Timestamp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TradeTax,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TradeMoney,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.Timestamp = 0
        self.TradeTax = 0
        self.TradeMoney = 0
        self.ItemDataLen = 0
        self.ItemData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.Timestamp)
        data = CommFunc.WriteDWORD(data, self.TradeTax)
        data = CommFunc.WriteDWORD(data, self.TradeMoney)
        data = CommFunc.WriteWORD(data, self.ItemDataLen)
        data = CommFunc.WriteString(data, self.ItemDataLen, self.ItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                Timestamp:%d,
                                TradeTax:%d,
                                TradeMoney:%d,
                                ItemDataLen:%d,
                                ItemData:%s
                                '''\
                                %(
                                self.Type,
                                self.Timestamp,
                                self.TradeTax,
                                self.TradeMoney,
                                self.ItemDataLen,
                                self.ItemData
                                )
        return DumpString


class  tagGCBourseRecordInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)//ÊýÁ¿
    RecordList = list()    #(vector<tagGCBourseRecord> RecordList)//size = Count
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temRecordList = tagGCBourseRecord()
            _pos = temRecordList.ReadData(_lpData, _pos)
            self.RecordList.append(temRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xAB
        self.Count = 0
        self.RecordList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#A9 AA ɾ³ýÓʼþ֪ͨ #tagGCDelCompensationResult

class  tagGCDelCompensationResult(Structure):
    Head = tagHead()
    GUID = ""    #(char GUID[40])
    Result = 0    #(BYTE Result)// ɾ³ý״̬ 0  ²»³É¹¦  1³É¹¦
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.GUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xAA
        self.GUID = ""
        self.Result = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 40, self.GUID)
        data = CommFunc.WriteBYTE(data, self.Result)
        return data

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


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


#------------------------------------------------------
# A9 04 ֪ͨÉñÊÞ¸±±¾NPCË¢ÐÂʱ¼ä #tagGCDogzNPCRefreshTime

class  tagDogzTimeInfoObj(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NPCID", c_int),    # npcid
                  ("RefreshSecond", 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.NPCID = 0
        self.RefreshSecond = 0
        return

    def GetLength(self):
        return sizeof(tagDogzTimeInfoObj)

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

    def OutputString(self):
        DumpString = '''// A9 04 ֪ͨÉñÊÞ¸±±¾NPCË¢ÐÂʱ¼ä //tagGCDogzNPCRefreshTime:
                                NPCID:%d,
                                RefreshSecond:%d
                                '''\
                                %(
                                self.NPCID,
                                self.RefreshSecond
                                )
        return DumpString


class  tagGCDogzNPCRefreshTime(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)//ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagDogzTimeInfoObj> InfoList)//ÐÅÏ¢Áбí
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A9 A9 ֪ͨºÃÓÑ»¥Ôù¾«Á¦ÐÅÏ¢ #tagGCFriendSendEnergyInfo

class  tagGCFriendSendEnergyInfo(Structure):
    Head = tagHead()
    DataSize = 0    #(DWORD DataSize)
    SendData = ""    #(String SendData)//ÔùËͼǼ
    RecvSize = 0    #(DWORD RecvSize)
    RecvData = ""    #(String RecvData)//¿É½ÓÊռǼ
    HasRecvCnt = 0    #(DWORD HasRecvCnt)//ÒѽÓÊÕ¸öÊý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.DataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SendData,_pos = CommFunc.ReadString(_lpData, _pos,self.DataSize)
        self.RecvSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RecvData,_pos = CommFunc.ReadString(_lpData, _pos,self.RecvSize)
        self.HasRecvCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xA9
        self.DataSize = 0
        self.SendData = ""
        self.RecvSize = 0
        self.RecvData = ""
        self.HasRecvCnt = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += len(self.SendData)
        length += 4
        length += len(self.RecvData)
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.DataSize)
        data = CommFunc.WriteString(data, self.DataSize, self.SendData)
        data = CommFunc.WriteDWORD(data, self.RecvSize)
        data = CommFunc.WriteString(data, self.RecvSize, self.RecvData)
        data = CommFunc.WriteDWORD(data, self.HasRecvCnt)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                DataSize:%d,
                                SendData:%s,
                                RecvSize:%d,
                                RecvData:%s,
                                HasRecvCnt:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.DataSize,
                                self.SendData,
                                self.RecvSize,
                                self.RecvData,
                                self.HasRecvCnt
                                )
        return DumpString


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


#------------------------------------------------------
#A9 02 ÊÀ½çbossÏà¹ØÐÅÏ¢ #tagGCGameWorldBossInfo

class  tagBossInfoObj(Structure):
    BossID = 0    #(DWORD BossID)// bossID
    IsAlive = 0    #(BYTE IsAlive)// ÊÇ·ñ´æ»î
    RecordLen = 0    #(WORD RecordLen)// ³¤¶È
    KillRecord = ""    #(String KillRecord)// ×î½ü»÷ɱ¼Ç¼ʱ¼äÍæ¼ÒÃûsize = RecordLen
    RefreshSecond = 0    #(DWORD RefreshSecond)// ˢе¹¼Æʱ, Ãë	
    RefreshCD = 0    #(DWORD RefreshCD)// Ë¢ÐÂ×ÜCDʱ, Ãë	
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.BossID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsAlive,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RecordLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.KillRecord,_pos = CommFunc.ReadString(_lpData, _pos,self.RecordLen)
        self.RefreshSecond,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RefreshCD,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.BossID = 0
        self.IsAlive = 0
        self.RecordLen = 0
        self.KillRecord = ""
        self.RefreshSecond = 0
        self.RefreshCD = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.BossID)
        data = CommFunc.WriteBYTE(data, self.IsAlive)
        data = CommFunc.WriteWORD(data, self.RecordLen)
        data = CommFunc.WriteString(data, self.RecordLen, self.KillRecord)
        data = CommFunc.WriteDWORD(data, self.RefreshSecond)
        data = CommFunc.WriteDWORD(data, self.RefreshCD)
        return data

    def OutputString(self):
        DumpString = '''
                                BossID:%d,
                                IsAlive:%d,
                                RecordLen:%d,
                                KillRecord:%s,
                                RefreshSecond:%d,
                                RefreshCD:%d
                                '''\
                                %(
                                self.BossID,
                                self.IsAlive,
                                self.RecordLen,
                                self.KillRecord,
                                self.RefreshSecond,
                                self.RefreshCD
                                )
        return DumpString


class  tagGCGameWorldBossInfo(Structure):
    Head = tagHead()
    BossCnt = 0    #(BYTE BossCnt)//bossÐÅÏ¢¸öÊý
    BossInfoList = list()    #(vector<tagBossInfoObj> BossInfoList)//bossÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.BossCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BossCnt):
            temBossInfoList = tagBossInfoObj()
            _pos = temBossInfoList.ReadData(_lpData, _pos)
            self.BossInfoList.append(temBossInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x02
        self.BossCnt = 0
        self.BossInfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 08 ¶É½Ù¸±±¾»¤·¨Í¨Öª #tagGCRealmFBHelpInfo

class  tagGCRealmFBHelpInfo(Structure):
    Head = tagHead()
    PlayerName = ""    #(char PlayerName[33])//Íæ¼ÒÃû×Ö
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    RealmLV = 0    #(BYTE RealmLV)//Íæ¼Ò¾³½ç
    Job = 0    #(BYTE Job)//Íæ¼ÒÖ°Òµ
    JobRank = 0    #(BYTE JobRank)//Íæ¼ÒÖ°Òµ½×¼¶
    AtkAdd = 0    #(BYTE AtkAdd)//»ñµÃ¼Ó³É
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobRank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AtkAdd,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x08
        self.PlayerName = ""
        self.PlayerID = 0
        self.RealmLV = 0
        self.Job = 0
        self.JobRank = 0
        self.AtkAdd = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.RealmLV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobRank)
        data = CommFunc.WriteBYTE(data, self.AtkAdd)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerName:%s,
                                PlayerID:%d,
                                RealmLV:%d,
                                Job:%d,
                                JobRank:%d,
                                AtkAdd:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerName,
                                self.PlayerID,
                                self.RealmLV,
                                self.Job,
                                self.JobRank,
                                self.AtkAdd
                                )
        return DumpString


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


#------------------------------------------------------
# A9 A7 ֪ͨ¿ÉÇÀµÄºì°üÐÅÏ¢ #tagGCGrabRedPacketInfo

class  tagGCGrabRedPacketInfo(Structure):
    Head = tagHead()
    RedPacketCnt = 0    #(DWORD RedPacketCnt)//¿ÉÇÀºì°ü¸öÊý
    StrLen = 0    #(WORD StrLen)//×Ö·û´®³¤¶È
    OwnerName = ""    #(String OwnerName)//ºì°üÖ÷ÈËÃû×Ö
    RedPacketID = 0    #(DWORD RedPacketID)//¿ÉÇÀºì°üID
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A9 A6 ֪ͨÇÀºì°ü½á¹û #tagGCGrabRedPacketResult

class  tagGCGrabRedPacketResult(Structure):
    Head = tagHead()
    StrLen = 0    #(WORD StrLen)//×Ö·û´®³¤¶È
    OwnerName = ""    #(String OwnerName)//ºì°üÖ÷ÈËÃû×Ö
    TotalMoney = 0    #(DWORD TotalMoney)//ºì°ü×ܶî
    DataSize = 0    #(DWORD DataSize)
    GrabInfo = ""    #(String GrabInfo)//ÇÀºì°ü¾ßÌå½á¹û
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# A9 05 ֪ͨ¹ã²¥×°±¸ÏêϸÐÅÏ¢ #tagGCNotifyEquipDetailInfo

class  tagGCNotifyEquipClassEquip(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("Star", c_ubyte),    
                  ]

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

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

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

    def GetLength(self):
        return sizeof(tagGCNotifyEquipClassEquip)

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

    def OutputString(self):
        DumpString = '''// A9 05 ֪ͨ¹ã²¥×°±¸ÏêϸÐÅÏ¢ //tagGCNotifyEquipDetailInfo:
                                ItemID:%d,
                                Star:%d
                                '''\
                                %(
                                self.ItemID,
                                self.Star
                                )
        return DumpString


class  tagGCNotifyEquipDetailInfo(Structure):
    Head = tagHead()
    ItemGUID = ""    #(char ItemGUID[40])
    ItemID = 0    #(DWORD ItemID)
    Star = 0    #(BYTE Star)//ÐǼ¶
    PlusLV = 0    #(WORD PlusLV)//Ç¿»¯µÈ¼¶
    EvolveLV = 0    #(BYTE EvolveLV)//½ø»¯µÈ¼¶
    WashLV = 0    #(BYTE WashLV)//Ï´Á·µÈ¼¶
    WashValueCount = 0    #(BYTE WashValueCount)
    WashValueList = list()    #(vector<DWORD> WashValueList)//Ï´Á·Öµ
    StoneIDCount = 0    #(BYTE StoneIDCount)
    StoneIDList = list()    #(vector<DWORD> StoneIDList)//±¦Ê¯
    ClassEquipCount = 0    #(BYTE ClassEquipCount)
    ClassEquipList = list()    #(vector<tagGCNotifyEquipClassEquip> ClassEquipList)//±¾¾³½ç´©´÷µÄ×°±¸
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Star,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlusLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.EvolveLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WashLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WashValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WashValueCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.WashValueList.append(value)
        self.StoneIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.StoneIDCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.StoneIDList.append(value)
        self.ClassEquipCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ClassEquipCount):
            temClassEquipList = tagGCNotifyEquipClassEquip()
            _pos = temClassEquipList.ReadData(_lpData, _pos)
            self.ClassEquipList.append(temClassEquipList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x05
        self.ItemGUID = ""
        self.ItemID = 0
        self.Star = 0
        self.PlusLV = 0
        self.EvolveLV = 0
        self.WashLV = 0
        self.WashValueCount = 0
        self.WashValueList = list()
        self.StoneIDCount = 0
        self.StoneIDList = list()
        self.ClassEquipCount = 0
        self.ClassEquipList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 40
        length += 4
        length += 1
        length += 2
        length += 1
        length += 1
        length += 1
        length += 4 * self.WashValueCount
        length += 1
        length += 4 * self.StoneIDCount
        length += 1
        for i in range(self.ClassEquipCount):
            length += self.ClassEquipList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteBYTE(data, self.Star)
        data = CommFunc.WriteWORD(data, self.PlusLV)
        data = CommFunc.WriteBYTE(data, self.EvolveLV)
        data = CommFunc.WriteBYTE(data, self.WashLV)
        data = CommFunc.WriteBYTE(data, self.WashValueCount)
        for i in range(self.WashValueCount):
            data = CommFunc.WriteDWORD(data, self.WashValueList[i])
        data = CommFunc.WriteBYTE(data, self.StoneIDCount)
        for i in range(self.StoneIDCount):
            data = CommFunc.WriteDWORD(data, self.StoneIDList[i])
        data = CommFunc.WriteBYTE(data, self.ClassEquipCount)
        for i in range(self.ClassEquipCount):
            data = CommFunc.WriteString(data, self.ClassEquipList[i].GetLength(), self.ClassEquipList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemGUID:%s,
                                ItemID:%d,
                                Star:%d,
                                PlusLV:%d,
                                EvolveLV:%d,
                                WashLV:%d,
                                WashValueCount:%d,
                                WashValueList:%s,
                                StoneIDCount:%d,
                                StoneIDList:%s,
                                ClassEquipCount:%d,
                                ClassEquipList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemGUID,
                                self.ItemID,
                                self.Star,
                                self.PlusLV,
                                self.EvolveLV,
                                self.WashLV,
                                self.WashValueCount,
                                "...",
                                self.StoneIDCount,
                                "...",
                                self.ClassEquipCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
#A9 03 ¿ª·þ»î¶¯½±ÀøÊýÁ¿Ë¢ÐÂ#tagGCOpenServerCampaignAwardCount

class  tagGCOpenServerCampaignAwardCount(Structure):
    Head = tagHead()
    CampaignType = 0    #(BYTE CampaignType)//½±ÀøÀàÐÍ
    AwardTypeCount = 0    #(BYTE AwardTypeCount)//½±Æ·ÖÖÀàÊýÁ¿
    GotCountList = list()    #(vector<DWORD> GotCountList)//½±Æ·ÒÑÁìÈ¡ÊýÁ¿ÁÐ±í£¬¸ù¾ÝÖÖÀàË÷ÒýÒÀ´Î
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x03
        self.CampaignType = 0
        self.AwardTypeCount = 0
        self.GotCountList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CampaignType:%d,
                                AwardTypeCount:%d,
                                GotCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CampaignType,
                                self.AwardTypeCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# A9 A2 ÅÅÐаñÐÅÏ¢#tagPYBillboardData

class  tagPYBillboardInfo(Structure):
    OrderIndex = 0    #(DWORD OrderIndex)//Ãû´ÎË÷Òý£¬0´ú±íµÚÒ»Ãû
    ID = 0    #(DWORD ID)
    ID2 = 0    #(DWORD ID2)
    Name1 = ""    #(char Name1[33])//Ãû×Ö1£¬ÓÃÀ´ÏÔʾÅÅÐò¶ÔÏóÃû×Ö 
    Name2 = ""    #(char Name2[33])//Ãû×Ö2
    Type2 = 0    #(BYTE Type2)//¸½¼ÓÀàÐÍ£¬ÓÃÀ´±íʾÅÅÐò¶ÔÏóµÄÀàÐÍ£¬±ÈÈ磬Íæ¼ÒËùÊôÖ°ÒµÃÅÅÉ£¬³èÎïÀàÐ͵È
    Value1 = 0    #(DWORD Value1)//ÅÅÐòÒÀÀµµÄÖµ£¬±ÈÈ磬µÈ¼¶
    Value2 = 0    #(DWORD Value2)//ÅÅÐòÒÀÀµµÄÖµ£¬±ÈÈ磬ս¶·Á¦
    Value3 = 0    #(DWORD Value3)//¸½¼ÓÖµ
    Value4 = 0    #(DWORD Value4)//¸½¼ÓÖµ
    Value5 = 0    #(DWORD Value5)//¸½¼ÓÖµ
    Value6 = 0    #(DWORD Value6)//¸½¼ÓÖµ
    Value7 = 0    #(DWORD Value7)//¸½¼ÓÖµ
    Value8 = 0    #(DWORD Value8)//¸½¼ÓÖµ
    CmpValue = 0    #(DWORD CmpValue)// ±È½ÏȨֵ
    CmpValue2 = 0    #(DWORD CmpValue2)// ±È½ÏȨֵ
    CmpValue3 = 0    #(DWORD CmpValue3)// ±È½ÏȨֵ
    DataLen = 0    #(WORD DataLen)
    UserData = ""    #(String UserData)//¸½¼Ó
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.OrderIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ID2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Name1,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Name2,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Type2,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
        return _pos

    def Clear(self):
        self.OrderIndex = 0
        self.ID = 0
        self.ID2 = 0
        self.Name1 = ""
        self.Name2 = ""
        self.Type2 = 0
        self.Value1 = 0
        self.Value2 = 0
        self.Value3 = 0
        self.Value4 = 0
        self.Value5 = 0
        self.Value6 = 0
        self.Value7 = 0
        self.Value8 = 0
        self.CmpValue = 0
        self.CmpValue2 = 0
        self.CmpValue3 = 0
        self.DataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.OrderIndex)
        data = CommFunc.WriteDWORD(data, self.ID)
        data = CommFunc.WriteDWORD(data, self.ID2)
        data = CommFunc.WriteString(data, 33, self.Name1)
        data = CommFunc.WriteString(data, 33, self.Name2)
        data = CommFunc.WriteBYTE(data, self.Type2)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        data = CommFunc.WriteDWORD(data, self.Value3)
        data = CommFunc.WriteDWORD(data, self.Value4)
        data = CommFunc.WriteDWORD(data, self.Value5)
        data = CommFunc.WriteDWORD(data, self.Value6)
        data = CommFunc.WriteDWORD(data, self.Value7)
        data = CommFunc.WriteDWORD(data, self.Value8)
        data = CommFunc.WriteDWORD(data, self.CmpValue)
        data = CommFunc.WriteDWORD(data, self.CmpValue2)
        data = CommFunc.WriteDWORD(data, self.CmpValue3)
        data = CommFunc.WriteWORD(data, self.DataLen)
        data = CommFunc.WriteString(data, self.DataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                OrderIndex:%d,
                                ID:%d,
                                ID2:%d,
                                Name1:%s,
                                Name2:%s,
                                Type2:%d,
                                Value1:%d,
                                Value2:%d,
                                Value3:%d,
                                Value4:%d,
                                Value5:%d,
                                Value6:%d,
                                Value7:%d,
                                Value8:%d,
                                CmpValue:%d,
                                CmpValue2:%d,
                                CmpValue3:%d,
                                DataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.OrderIndex,
                                self.ID,
                                self.ID2,
                                self.Name1,
                                self.Name2,
                                self.Type2,
                                self.Value1,
                                self.Value2,
                                self.Value3,
                                self.Value4,
                                self.Value5,
                                self.Value6,
                                self.Value7,
                                self.Value8,
                                self.CmpValue,
                                self.CmpValue2,
                                self.CmpValue3,
                                self.DataLen,
                                self.UserData
                                )
        return DumpString


class  tagPYBillboardData(Structure):
    Head = tagHead()
    WatchID = 0    #(DWORD WatchID)//²é¿´Ö¸¶¨IDÃû´ÎÇ°ºó£¬ÈçÍæ¼ÒID¡¢¼Ò×åIDµÈ
    BillboardCount = 0    #(BYTE BillboardCount)
    Type = 0    #(BYTE Type)//ÅÅÐаñÀàÐÍ
    Billboard = list()    #(vector<tagPYBillboardInfo> Billboard)//size = BillboardCount
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.WatchID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BillboardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BillboardCount):
            temBillboard = tagPYBillboardInfo()
            _pos = temBillboard.ReadData(_lpData, _pos)
            self.Billboard.append(temBillboard)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xA2
        self.WatchID = 0
        self.BillboardCount = 0
        self.Type = 0
        self.Billboard = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.WatchID)
        data = CommFunc.WriteBYTE(data, self.BillboardCount)
        data = CommFunc.WriteBYTE(data, self.Type)
        for i in range(self.BillboardCount):
            data = CommFunc.WriteString(data, self.Billboard[i].GetLength(), self.Billboard[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                WatchID:%d,
                                BillboardCount:%d,
                                Type:%d,
                                Billboard:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.WatchID,
                                self.BillboardCount,
                                self.Type,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# A9 A3 À®°ÈÁÄÌìÄÚÈÝ #tagGCPYSpeakerContent

class  tagGCPYSpeakerContent(Structure):
    Head = tagHead()
    AccIDLen = 0    #(BYTE AccIDLen)
    AccID = ""    #(String AccID)//size = AccIDLen
    PlayerID = 0    #(DWORD PlayerID)// ×Ó·þµÄÍæ¼ÒID£¬¸ÃIDÓÐֵʱΪ±¾·þÍæ¼Ò
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//size = NameLen
    SpeakerType = 0    #(BYTE SpeakerType)
    TextLen = 0    #(WORD TextLen)
    Text = ""    #(String Text)//size = TextLen
    ExtraValue = 0    #(DWORD ExtraValue)//¸½¼ÓÖµ
    Extras = ""    #(char Extras[256])//¸½¼ÓÖµÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AccIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,self.AccIDLen)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.SpeakerType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TextLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Text,_pos = CommFunc.ReadString(_lpData, _pos,self.TextLen)
        self.ExtraValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,256)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xA3
        self.AccIDLen = 0
        self.AccID = ""
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.SpeakerType = 0
        self.TextLen = 0
        self.Text = ""
        self.ExtraValue = 0
        self.Extras = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.AccID)
        length += 4
        length += 1
        length += len(self.Name)
        length += 1
        length += 2
        length += len(self.Text)
        length += 4
        length += 256

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.AccIDLen)
        data = CommFunc.WriteString(data, self.AccIDLen, self.AccID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteBYTE(data, self.SpeakerType)
        data = CommFunc.WriteWORD(data, self.TextLen)
        data = CommFunc.WriteString(data, self.TextLen, self.Text)
        data = CommFunc.WriteDWORD(data, self.ExtraValue)
        data = CommFunc.WriteString(data, 256, self.Extras)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AccIDLen:%d,
                                AccID:%s,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                SpeakerType:%d,
                                TextLen:%d,
                                Text:%s,
                                ExtraValue:%d,
                                Extras:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AccIDLen,
                                self.AccID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.SpeakerType,
                                self.TextLen,
                                self.Text,
                                self.ExtraValue,
                                self.Extras
                                )
        return DumpString


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


#------------------------------------------------------
#A9 A1 ²éѯÍæ¼Ò²¹³¥½á¹û·â°ü#tagGCQueryCompensationResult

class  tagGCCompensationItem(Structure):
    ItemID = 0    #(DWORD ItemID)//ÎïÆ·ID
    Count = 0    #(DWORD Count)//ÊýÁ¿
    IsBind = 0    #(BYTE IsBind)//ÊÇ·ñ°ó¶¨
    UserDataLen = 0    #(DWORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý	
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsBind,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemID = 0
        self.Count = 0
        self.IsBind = 0
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteDWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.IsBind)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemID:%d,
                                Count:%d,
                                IsBind:%d,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemID,
                                self.Count,
                                self.IsBind,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCCompensationPack(Structure):
    GUID = ""    #(char GUID[40])//²¹³¥±êʶ
    CreateTime = ""    #(char CreateTime[30])//Óʼþ½ÓÊÕʱ¼ä
    TextLen = 0    #(DWORD TextLen)//ÎÄ×ÖÄÚÈݳ¤¶È
    Text = ""    #(String Text)//ÎÄ×ÖÄÚÈÝ
    Count = 0    #(BYTE Count)//µ±Ç°²¹³¥ÎïÆ·Êý
    IsRead = 0    #(BYTE IsRead)//ÒѶÁ״̬ 0 δ¶ÁÈ¡ 1ÒѶÁÈ¡
    Gold = 0    #(DWORD Gold)//ÏÉÓñ
    GoldPaper = 0    #(DWORD GoldPaper)//°ó¶¨ÏÉÓñ
    Silver = 0    #(DWORD Silver)//Í­Ç®
    Items = list()    #(vector<tagGCCompensationItem> Items)//²¹³¥ÎïÆ·ÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.CreateTime,_pos = CommFunc.ReadString(_lpData, _pos,30)
        self.TextLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Text,_pos = CommFunc.ReadString(_lpData, _pos,self.TextLen)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsRead,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Gold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GoldPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Silver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        for i in range(self.Count):
            temItems = tagGCCompensationItem()
            _pos = temItems.ReadData(_lpData, _pos)
            self.Items.append(temItems)
        return _pos

    def Clear(self):
        self.GUID = ""
        self.CreateTime = ""
        self.TextLen = 0
        self.Text = ""
        self.Count = 0
        self.IsRead = 0
        self.Gold = 0
        self.GoldPaper = 0
        self.Silver = 0
        self.Items = list()
        return

    def GetLength(self):
        length = 0
        length += 40
        length += 30
        length += 4
        length += len(self.Text)
        length += 1
        length += 1
        length += 4
        length += 4
        length += 4
        for i in range(self.Count):
            length += self.Items[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.GUID)
        data = CommFunc.WriteString(data, 30, self.CreateTime)
        data = CommFunc.WriteDWORD(data, self.TextLen)
        data = CommFunc.WriteString(data, self.TextLen, self.Text)
        data = CommFunc.WriteBYTE(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.IsRead)
        data = CommFunc.WriteDWORD(data, self.Gold)
        data = CommFunc.WriteDWORD(data, self.GoldPaper)
        data = CommFunc.WriteDWORD(data, self.Silver)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.Items[i].GetLength(), self.Items[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GUID:%s,
                                CreateTime:%s,
                                TextLen:%d,
                                Text:%s,
                                Count:%d,
                                IsRead:%d,
                                Gold:%d,
                                GoldPaper:%d,
                                Silver:%d,
                                Items:%s
                                '''\
                                %(
                                self.GUID,
                                self.CreateTime,
                                self.TextLen,
                                self.Text,
                                self.Count,
                                self.IsRead,
                                self.Gold,
                                self.GoldPaper,
                                self.Silver,
                                "..."
                                )
        return DumpString


class  tagGCQueryCompensationResult(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)//¿ÉÁìÈ¡²¹³¥Êý
    PackList = list()    #(vector<tagGCCompensationPack> PackList)//²¹³¥ÎïÆ·ÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temPackList = tagGCCompensationPack()
            _pos = temPackList.ReadData(_lpData, _pos)
            self.PackList.append(temPackList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xA1
        self.Count = 0
        self.PackList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 A8 ֪ͨ¿ÉÌí¼ÓµÄºÃÓÑÐÅÏ¢ #tagGCRecommendFriendsInfo

class  tagRecommendFriendsData(Structure):
    ID = 0    #(DWORD ID)
    Name = ""    #(char Name[33])
    LV = 0    #(DWORD LV)//µÈ¼¶
    Job = 0    #(BYTE Job)
    RealmLV = 0    #(WORD RealmLV)//¾³½ç	
    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.ID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.LV,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ID = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ID)
        data = CommFunc.WriteString(data, 33, self.Name)
        data = CommFunc.WriteDWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

    def OutputString(self):
        DumpString = '''
                                ID:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d
                                '''\
                                %(
                                self.ID,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic
                                )
        return DumpString


class  tagGCRecommendFriendsInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)//ÐÅÏ¢Êý
    FriendsList = list()    #(vector<tagRecommendFriendsData> FriendsList)//³ÉÔ±ÐÅÏ¢
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xA8
        self.Cnt = 0
        self.FriendsList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A9 AD ֪ͨÌìÐÇËþÈ«·þ½±Àøͨ¹ØÍæ¼ÒÐÅÏ¢ #tagGCSkyTowerPassPlayerInfo

class  tagGCSkyTowerPassPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCSkyTowerPassFloor(Structure):
    FloorID = 0    #(DWORD FloorID)// ²ãID
    PassPlayerCount = 0    #(BYTE PassPlayerCount)// ͨ¹Ø¼Ç¼Íæ¼ÒÊý
    PassPlayerIDList = list()    #(vector<DWORD> PassPlayerIDList)// ͨ¹Ø¼Ç¼Íæ¼ÒIDÁбí [µÚ1¸öͨ¹ýÍæ¼ÒID, µÚ2¸ö, ...]
    data = None

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

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

    def Clear(self):
        self.FloorID = 0
        self.PassPlayerCount = 0
        self.PassPlayerIDList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.FloorID)
        data = CommFunc.WriteBYTE(data, self.PassPlayerCount)
        for i in range(self.PassPlayerCount):
            data = CommFunc.WriteDWORD(data, self.PassPlayerIDList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                FloorID:%d,
                                PassPlayerCount:%d,
                                PassPlayerIDList:%s
                                '''\
                                %(
                                self.FloorID,
                                self.PassPlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCSkyTowerPassPlayerInfo(Structure):
    Head = tagHead()
    FloorCount = 0    #(WORD FloorCount)
    PassFloorList = list()    #(vector<tagGCSkyTowerPassFloor> PassFloorList)// ͨ¹ØËþ²ãÐÅÏ¢Áбí
    PlayerCount = 0    #(WORD PlayerCount)
    PassPlayerList = list()    #(vector<tagGCSkyTowerPassPlayer> PassPlayerList)// ͨ¹ØÍæ¼ÒÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FloorCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.FloorCount):
            temPassFloorList = tagGCSkyTowerPassFloor()
            _pos = temPassFloorList.ReadData(_lpData, _pos)
            self.PassFloorList.append(temPassFloorList)
        self.PlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.PlayerCount):
            temPassPlayerList = tagGCSkyTowerPassPlayer()
            _pos = temPassPlayerList.ReadData(_lpData, _pos)
            self.PassPlayerList.append(temPassPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0xAD
        self.FloorCount = 0
        self.PassFloorList = list()
        self.PlayerCount = 0
        self.PassPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.FloorCount):
            length += self.PassFloorList[i].GetLength()
        length += 2
        for i in range(self.PlayerCount):
            length += self.PassPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.FloorCount)
        for i in range(self.FloorCount):
            data = CommFunc.WriteString(data, self.PassFloorList[i].GetLength(), self.PassFloorList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.PlayerCount)
        for i in range(self.PlayerCount):
            data = CommFunc.WriteString(data, self.PassPlayerList[i].GetLength(), self.PassPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FloorCount:%d,
                                PassFloorList:%s,
                                PlayerCount:%d,
                                PassPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FloorCount,
                                "...",
                                self.PlayerCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# A9 06 É̳ÇÈ«·þ¹ºÂò´ÎÊý֪ͨ #tagGCStoreServerBuyCntInfo

class  tagGCStoreServerBuyCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GoodsID", c_int),    #ÉÌÆ·±êʶ
                  ("BuyCnt", 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.GoodsID = 0
        self.BuyCnt = 0
        return

    def GetLength(self):
        return sizeof(tagGCStoreServerBuyCnt)

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

    def OutputString(self):
        DumpString = '''// A9 06 É̳ÇÈ«·þ¹ºÂò´ÎÊý֪ͨ //tagGCStoreServerBuyCntInfo:
                                GoodsID:%d,
                                BuyCnt:%d
                                '''\
                                %(
                                self.GoodsID,
                                self.BuyCnt
                                )
        return DumpString


class  tagGCStoreServerBuyCntInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)//ÊýÁ¿
    InfoList = list()    #(vector<tagGCStoreServerBuyCnt> InfoList)//´ÎÊýÐÅÏ¢
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x06
        self.Count = 0
        self.InfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#A9 21 ½ÇÉ«¸ÄÃû½á¹û #tagUpdatePlayerNameResult

class  tagUpdatePlayerNameResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Result", c_ubyte),    #½ÇÉ«¸ÄÃû½á¹û
                  ]

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

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

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

    def GetLength(self):
        return sizeof(tagUpdatePlayerNameResult)

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

    def OutputString(self):
        DumpString = '''//A9 21 ½ÇÉ«¸ÄÃû½á¹û //tagUpdatePlayerNameResult:
                                Cmd:%s,
                                SubCmd:%s,
                                Result:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Result
                                )
        return DumpString


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


#------------------------------------------------------
# A9 27 Ïɹ¬Ð½úÍæ¼ÒÐÅÏ¢ #tagGCXiangongNewPlayerInfo

class  tagGCXiangongNewPlayer(Structure):
    AddTime = 0    #(DWORD AddTime)// нúʱ¼ä´Á
    ServerID = 0    #(DWORD ServerID)
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    EquipShowSwitch = 0    #(DWORD EquipShowSwitch)
    EquipShowIDCount = 0    #(BYTE EquipShowIDCount)
    EquipShowID = list()    #(vector<DWORD> EquipShowID)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AddTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipShowSwitch,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipShowIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.EquipShowIDCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.EquipShowID.append(value)
        return _pos

    def Clear(self):
        self.AddTime = 0
        self.ServerID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.EquipShowSwitch = 0
        self.EquipShowIDCount = 0
        self.EquipShowID = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.ServerID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.EquipShowSwitch)
        data = CommFunc.WriteBYTE(data, self.EquipShowIDCount)
        for i in range(self.EquipShowIDCount):
            data = CommFunc.WriteDWORD(data, self.EquipShowID[i])
        return data

    def OutputString(self):
        DumpString = '''
                                AddTime:%d,
                                ServerID:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                EquipShowSwitch:%d,
                                EquipShowIDCount:%d,
                                EquipShowID:%s
                                '''\
                                %(
                                self.AddTime,
                                self.ServerID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.EquipShowSwitch,
                                self.EquipShowIDCount,
                                "..."
                                )
        return DumpString


class  tagGCXiangongNewPlayerInfo(Structure):
    Head = tagHead()
    XiangongID = 0    #(WORD XiangongID)// Ïɹ¬ID
    NewPlayerCount = 0    #(BYTE NewPlayerCount)
    NewPlayerList = list()    #(vector<tagGCXiangongNewPlayer> NewPlayerList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.XiangongID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.NewPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.NewPlayerCount):
            temNewPlayerList = tagGCXiangongNewPlayer()
            _pos = temNewPlayerList.ReadData(_lpData, _pos)
            self.NewPlayerList.append(temNewPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x27
        self.XiangongID = 0
        self.NewPlayerCount = 0
        self.NewPlayerList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                XiangongID:%d,
                                NewPlayerCount:%d,
                                NewPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.XiangongID,
                                self.NewPlayerCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# A9 28 Ïɹ¬ÏÉÃû¼Íæ¼ÒÐÅÏ¢ #tagGCXiangongRecPlayerInfo

class  tagGCXiangongRecPlayer(Structure):
    AddTime = 0    #(DWORD AddTime)// нúʱ¼ä´Á
    ServerID = 0    #(DWORD ServerID)
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½ç
    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.AddTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.AddTime = 0
        self.ServerID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.ServerID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

    def OutputString(self):
        DumpString = '''
                                AddTime:%d,
                                ServerID:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d
                                '''\
                                %(
                                self.AddTime,
                                self.ServerID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic
                                )
        return DumpString


class  tagGCXiangongRecPlayerInfo(Structure):
    Head = tagHead()
    XiangongID = 0    #(WORD XiangongID)// Ïɹ¬ID
    RecPlayerCount = 0    #(BYTE RecPlayerCount)
    RecPlayerList = list()    #(vector<tagGCXiangongRecPlayer> RecPlayerList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.XiangongID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RecPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RecPlayerCount):
            temRecPlayerList = tagGCXiangongRecPlayer()
            _pos = temRecPlayerList.ReadData(_lpData, _pos)
            self.RecPlayerList.append(temRecPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA9
        self.Head.SubCmd = 0x28
        self.XiangongID = 0
        self.RecPlayerCount = 0
        self.RecPlayerList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                XiangongID:%d,
                                RecPlayerCount:%d,
                                RecPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.XiangongID,
                                self.RecPlayerCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# AC 10 ÏÉÃËÇÀBossËùÓÐBossÉËѪ½ø¶ÈÐÅÏ¢ #tagGCAllFamilyBossHurtInfoList

class  tagGCFamilyBossHurtInfo(Structure):
    NPCID = 0    #(DWORD NPCID)
    CurHP = 0    #(DWORD CurHP)
    CurHPEx = 0    #(DWORD CurHPEx)
    MaxHP = 0    #(DWORD MaxHP)
    MaxHPEx = 0    #(DWORD MaxHPEx)
    FamilyID = 0    #(DWORD FamilyID)// ×î´óʵʱÉËѪÏÉÃË
    NameLen = 0    #(BYTE NameLen)
    FamilyName = ""    #(String FamilyName)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CurHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CurHPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FamilyName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        return _pos

    def Clear(self):
        self.NPCID = 0
        self.CurHP = 0
        self.CurHPEx = 0
        self.MaxHP = 0
        self.MaxHPEx = 0
        self.FamilyID = 0
        self.NameLen = 0
        self.FamilyName = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteDWORD(data, self.CurHP)
        data = CommFunc.WriteDWORD(data, self.CurHPEx)
        data = CommFunc.WriteDWORD(data, self.MaxHP)
        data = CommFunc.WriteDWORD(data, self.MaxHPEx)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.FamilyName)
        return data

    def OutputString(self):
        DumpString = '''
                                NPCID:%d,
                                CurHP:%d,
                                CurHPEx:%d,
                                MaxHP:%d,
                                MaxHPEx:%d,
                                FamilyID:%d,
                                NameLen:%d,
                                FamilyName:%s
                                '''\
                                %(
                                self.NPCID,
                                self.CurHP,
                                self.CurHPEx,
                                self.MaxHP,
                                self.MaxHPEx,
                                self.FamilyID,
                                self.NameLen,
                                self.FamilyName
                                )
        return DumpString


class  tagGCAllFamilyBossHurtInfoList(Structure):
    Head = tagHead()
    NPCCount = 0    #(BYTE NPCCount)// ¸öÊý
    NPCHurtInfo = list()    #(vector<tagGCFamilyBossHurtInfo> NPCHurtInfo)// NPCÉËѪÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.NPCCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.NPCCount):
            temNPCHurtInfo = tagGCFamilyBossHurtInfo()
            _pos = temNPCHurtInfo.ReadData(_lpData, _pos)
            self.NPCHurtInfo.append(temNPCHurtInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x10
        self.NPCCount = 0
        self.NPCHurtInfo = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# AC 08 boss¸´»îµãÊý֪ͨ #tagGCBossRebornPoint

class  tagGCBossRebornPoint(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Point", c_int),    # ¸´»îµãÊý
                  ("TotalPoint", c_int),    # ¸´»î×ܵãÊý
                  ("RebornCnt", c_ushort),    # ½ñÈÕÒѸ´»î´ÎÊý
                  ("TotalRebornCnt", c_ushort),    # ÿÈտɸ´»î×Ü´ÎÊý£¬0Ϊ²»ÏÞÖÆ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAC
        self.SubCmd = 0x08
        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 = 0xAC
        self.SubCmd = 0x08
        self.Point = 0
        self.TotalPoint = 0
        self.RebornCnt = 0
        self.TotalRebornCnt = 0
        return

    def GetLength(self):
        return sizeof(tagGCBossRebornPoint)

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

    def OutputString(self):
        DumpString = '''// AC 08 boss¸´»îµãÊý֪ͨ //tagGCBossRebornPoint:
                                Cmd:%s,
                                SubCmd:%s,
                                Point:%d,
                                TotalPoint:%d,
                                RebornCnt:%d,
                                TotalRebornCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Point,
                                self.TotalPoint,
                                self.RebornCnt,
                                self.TotalRebornCnt
                                )
        return DumpString


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


#------------------------------------------------------
# AC 13 ¿ç·þÈ«Ãñ³äÖµ»î¶¯ÐÅÏ¢ #tagGCCrossActAllRechargeInfo

class  tagGCCrossActAllRechargeItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    # ÊÇ·ñÅÄÆ·
                  ]

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

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

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagGCCrossActAllRechargeItem)

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

    def OutputString(self):
        DumpString = '''// AC 13 ¿ç·þÈ«Ãñ³äÖµ»î¶¯ÐÅÏ¢ //tagGCCrossActAllRechargeInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagGCCrossActAllRechargeAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý 0~31
    NeedRMB = 0    #(DWORD NeedRMB)// ËùÐèÈ«Ãñ³äÖµRMB
    NeedPlayerCount = 0    #(WORD NeedPlayerCount)// ËùÐè³äÖµ´ïµ½¸ÃµµÍæ¼ÒÊý
    NowPlayerCount = 0    #(WORD NowPlayerCount)// µ±Ç°³äÖµ´ïµ½¸ÃµµÍæ¼ÒÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagGCCrossActAllRechargeItem> AwardItemList)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedRMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NeedPlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.NowPlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagGCCrossActAllRechargeItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedRMB = 0
        self.NeedPlayerCount = 0
        self.NowPlayerCount = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedRMB)
        data = CommFunc.WriteWORD(data, self.NeedPlayerCount)
        data = CommFunc.WriteWORD(data, self.NowPlayerCount)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedRMB:%d,
                                NeedPlayerCount:%d,
                                NowPlayerCount:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedRMB,
                                self.NeedPlayerCount,
                                self.NowPlayerCount,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagGCCrossActAllRechargeInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AwardCount = 0    #(BYTE AwardCount)
    AwardList = list()    #(vector<tagGCCrossActAllRechargeAward> AwardList)// ½±Àøµµ´ÎÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardList = tagGCCrossActAllRechargeAward()
            _pos = temAwardList.ReadData(_lpData, _pos)
            self.AwardList.append(temAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x13
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.StartDate = ""
        self.EndtDate = ""
        self.AwardCount = 0
        self.AwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 10
        length += 10
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ServerInfoLen)
        data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardList[i].GetLength(), self.AwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                AwardCount:%d,
                                AwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.StartDate,
                                self.EndtDate,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# AC 12 ¿ç·þÔËÓª»î¶¯½áÊø # tagGCCrossActEnd

class  tagGCCrossActEnd(Structure):
    Head = tagHead()
    ActNameLen = 0    #(BYTE ActNameLen)
    ActName = ""    #(String ActName)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ActName,_pos = CommFunc.ReadString(_lpData, _pos,self.ActNameLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x12
        self.ActNameLen = 0
        self.ActName = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNameLen)
        data = CommFunc.WriteString(data, self.ActNameLen, self.ActName)
        return data

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


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


#------------------------------------------------------
# AC 09 ÏɽçÊ¢µä»î¶¯ÐÅÏ¢ #tagGCFairyCeremonyInfo

class  tagGCFairyCeremonyInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    WorldLV = 0    #(WORD WorldLV)// ÊÀ½çµÈ¼¶
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ 0-0µãÖØÖà 1-5µãÖØÖÃ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.WorldLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x09
        self.StartDate = ""
        self.EndtDate = ""
        self.WorldLV = 0
        self.LimitLV = 0
        self.ResetType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 2
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.WorldLV)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        return data

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


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


#------------------------------------------------------
# AC 01 ÏÉÃËÁªÈüÐÅϢ֪ͨ #tagGCFamilyWarInfo

class  tagGCFamilyWarInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("WorldLV", c_ushort),    # µ±Ç°½øÐÐÖеÄÁªÈüÊÀ½çµÈ¼¶
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xAC
        self.SubCmd = 0x01
        self.WorldLV = 0
        return

    def GetLength(self):
        return sizeof(tagGCFamilyWarInfo)

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

    def OutputString(self):
        DumpString = '''// AC 01 ÏÉÃËÁªÈüÐÅϢ֪ͨ //tagGCFamilyWarInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                WorldLV:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.WorldLV
                                )
        return DumpString


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


#------------------------------------------------------
# AC 11 ½ÚÈÕºì°ü»î¶¯ÐÅÏ¢ #tagGCFeastRedPacketInfo

class  tagGCFeastRedPacketDay(Structure):
    RedPacketCount = 0    #(BYTE RedPacketCount)
    RedPacketIDList = list()    #(vector<WORD> RedPacketIDList)// µ±ÈÕ¶¨Ê±·¢·ÅµÄϵͳºì°ü±íIDÁбí
    data = None

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

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

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

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

        return length

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

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


class  tagGCFeastRedPacketInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ 0-0µãÖØÖà 1-5µãÖØÖÃ
    RedPacketDays = 0    #(BYTE RedPacketDays)
    RedPacketDayList = list()    #(vector<tagGCFeastRedPacketDay> RedPacketDayList)// ÿÈÕϵͳºì°üÐÅÏ¢
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# AC 02 ֪ͨÏÉħ֮ÕùÐÅÏ¢ #tagGCXMZZInfo

class  tagGCXMZZInfo(Structure):
    Head = tagHead()
    Len = 0    #(WORD Len)
    StageRecord = ""    #(String StageRecord)// ½×¶Îʤ¸º¼Ç¼
    Score1 = 0    #(DWORD Score1)// ÏɽçÕóÓª»ý·Ö
    Score2 = 0    #(DWORD Score2)// ħ½çÕóÓª»ý·Ö
    TopScore = 0    #(DWORD TopScore)// »ý·ÖµÚ1Ãû»ý·Ö
    TopName = ""    #(char TopName[33])// »ý·ÖµÚ1ÃûÃû×Ö
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.StageRecord,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        self.Score1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Score2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TopScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TopName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x02
        self.Len = 0
        self.StageRecord = ""
        self.Score1 = 0
        self.Score2 = 0
        self.TopScore = 0
        self.TopName = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.StageRecord)
        data = CommFunc.WriteDWORD(data, self.Score1)
        data = CommFunc.WriteDWORD(data, self.Score2)
        data = CommFunc.WriteDWORD(data, self.TopScore)
        data = CommFunc.WriteString(data, 33, self.TopName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Len:%d,
                                StageRecord:%s,
                                Score1:%d,
                                Score2:%d,
                                TopScore:%d,
                                TopName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Len,
                                self.StageRecord,
                                self.Score1,
                                self.Score2,
                                self.TopScore,
                                self.TopName
                                )
        return DumpString


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


#------------------------------------------------------
# AC 03 ֪ͨÏÉħ֮Õù×Ô¼ºÐÅÏ¢ #tagGCXMZZSelfInfo

class  tagGCXMZZSelfInfo(Structure):
    Head = tagHead()
    Faction = 0    #(BYTE Faction)// ËùÊôÕóÓª
    Score = 0    #(DWORD Score)// »ý·Ö
    WinCnt = 0    #(BYTE WinCnt)// ʤ³¡Êý
    WinCntAwardRecord = 0    #(DWORD WinCntAwardRecord)// ʤ³¡½±ÀøÁìÈ¡¼Ç¼
    Len = 0    #(WORD Len)// Ѻע¼Ç¼
    BetRecord = ""    #(String BetRecord)// Ѻע¼Ç¼
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Faction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WinCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WinCntAwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BetRecord,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x03
        self.Faction = 0
        self.Score = 0
        self.WinCnt = 0
        self.WinCntAwardRecord = 0
        self.Len = 0
        self.BetRecord = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Faction)
        data = CommFunc.WriteDWORD(data, self.Score)
        data = CommFunc.WriteBYTE(data, self.WinCnt)
        data = CommFunc.WriteDWORD(data, self.WinCntAwardRecord)
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.BetRecord)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Faction:%d,
                                Score:%d,
                                WinCnt:%d,
                                WinCntAwardRecord:%d,
                                Len:%d,
                                BetRecord:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Faction,
                                self.Score,
                                self.WinCnt,
                                self.WinCntAwardRecord,
                                self.Len,
                                self.BetRecord
                                )
        return DumpString


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


#------------------------------------------------------
# AC 07 Æï³èBossÐÅÏ¢ #tagGCHorsePetBossInfo

class  tagGCHorsePetBossInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsEnd", c_int),    # ÊÇ·ñÒѽáÊø(°´Î»´ú±í¶ÔÓ¦Ïß·ÊÇ·ñ½áÊø)
                  ]

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

    def GetLength(self):
        return sizeof(tagGCHorsePetBossInfo)

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

    def OutputString(self):
        DumpString = '''// AC 07 Æï³èBossÐÅÏ¢ //tagGCHorsePetBossInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                IsEnd:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsEnd
                                )
        return DumpString


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


#------------------------------------------------------
# AC 06 ¶à±¶¾­Ñé»î¶¯ÐÅÏ¢ #tagGCMultiExpRateInfo

class  tagGCMultiExpRateTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime
                                )
        return DumpString


class  tagGCMultiExpRateInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    ActivityTimeCount = 0    #(BYTE ActivityTimeCount)
    ActivityTime = list()    #(vector<tagGCMultiExpRateTime> ActivityTime)//»î¶¯Ê±¼ä
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AddExpRate = 0    #(DWORD AddExpRate)// Ôö¼ÓµÄ¾­Ñ鱶ÂÊ£¬Íò·ÖÂÊ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.ActivityTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActivityTimeCount):
            temActivityTime = tagGCMultiExpRateTime()
            _pos = temActivityTime.ReadData(_lpData, _pos)
            self.ActivityTime.append(temActivityTime)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddExpRate,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x06
        self.StartDate = ""
        self.EndtDate = ""
        self.ActivityTimeCount = 0
        self.ActivityTime = list()
        self.LimitLV = 0
        self.AddExpRate = 0
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                ActivityTimeCount:%d,
                                ActivityTime:%s,
                                LimitLV:%d,
                                AddExpRate:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.ActivityTimeCount,
                                "...",
                                self.LimitLV,
                                self.AddExpRate
                                )
        return DumpString


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


#------------------------------------------------------
# AC 0A ¶à±¶ÐÞÐеã»î¶¯ÐÅÏ¢ #tagGCMultiRealmPointInfo

class  tagGCMultiRealmPointInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    Multiple = 0    #(BYTE Multiple)// ±¶Êý
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    LimitPoint = 0    #(DWORD LimitPoint)// ÏÞÖÆ»ñµÃÐÞÐеã
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.Multiple,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LimitPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x0A
        self.StartDate = ""
        self.EndtDate = ""
        self.Multiple = 0
        self.LimitLV = 0
        self.LimitPoint = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.Multiple)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteDWORD(data, self.LimitPoint)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                Multiple:%d,
                                LimitLV:%d,
                                LimitPoint:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.Multiple,
                                self.LimitLV,
                                self.LimitPoint
                                )
        return DumpString


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


#------------------------------------------------------
# AC 0B ÐÂÏɽçÊ¢µä»î¶¯ÐÅÏ¢ #tagGCNewFairyCeremonyInfo

class  tagGCNewFairyCeremonyInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    WorldLV = 0    #(WORD WorldLV)// ÊÀ½çµÈ¼¶
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ 0-0µãÖØÖà 1-5µãÖØÖÃ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.WorldLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x0B
        self.StartDate = ""
        self.EndtDate = ""
        self.WorldLV = 0
        self.LimitLV = 0
        self.ResetType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 2
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.WorldLV)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        return data

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


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


#------------------------------------------------------
# AC 05 ºì°üɾ³ý #tagGCRedPacketDel

class  tagGCRedPacketDel(Structure):
    Head = tagHead()
    Cnt = 0    #(DWORD Cnt)// ¸öÊý
    DelRedPacketID = list()    #(vector<DWORD> DelRedPacketID)// ºì°üID
    data = None

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

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

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

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

        return length

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

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


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


#------------------------------------------------------
# AC 04 ֪ͨÏÉħ֮Õù¶ÔÕ½ÐÅÏ¢ #tagGCXMZZFightInfo

class  tagGCXMZZFightInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PropDataSize = 0    #(DWORD PropDataSize)
    PropData = ""    #(String PropData)//ÊôÐԼǼ
    ItemDataSize = 0    #(DWORD ItemDataSize)
    ItemData = ""    #(String ItemData)//ÎïÆ·¼Ç¼
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x04
        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.PropDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PropData,_pos = CommFunc.ReadString(_lpData, _pos,self.PropDataSize)
        self.ItemDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataSize)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAC
        self.Head.SubCmd = 0x04
        self.PlayerID = 0
        self.PropDataSize = 0
        self.PropData = ""
        self.ItemDataSize = 0
        self.ItemData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += len(self.PropData)
        length += 4
        length += len(self.ItemData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteDWORD(data, self.PropDataSize)
        data = CommFunc.WriteString(data, self.PropDataSize, self.PropData)
        data = CommFunc.WriteDWORD(data, self.ItemDataSize)
        data = CommFunc.WriteString(data, self.ItemDataSize, self.ItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PropDataSize:%d,
                                PropData:%s,
                                ItemDataSize:%d,
                                ItemData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PropDataSize,
                                self.PropData,
                                self.ItemDataSize,
                                self.ItemData
                                )
        return DumpString


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


#------------------------------------------------------
# AE 05 ïÚ³µ¿ªÊ¼Ê±¼ä #tagGCTruckStartTime

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

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

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

    def Clear(self):
        self.Cmd = 0xAE
        self.SubCmd = 0x05
        self.StartTime = 0
        return

    def GetLength(self):
        return sizeof(tagGCTruckStartTime)

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

    def OutputString(self):
        DumpString = '''// AE 05 ïÚ³µ¿ªÊ¼Ê±¼ä //tagGCTruckStartTime:
                                Cmd:%s,
                                SubCmd:%s,
                                StartTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.StartTime
                                )
        return DumpString


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


#------------------------------------------------------
# B0 01 ÐÂÔöЭÖú #tagGCAssistInfoList

class  tagGCAssistInfo(Structure):
    AssistGUID = ""    #(char AssistGUID[40])//ЭÖúGUID
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(BYTE RealmLV)//¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    MapID = 0    #(DWORD MapID)
    LineID = 0    #(DWORD LineID)
    NPCID = 0    #(DWORD NPCID)
    ExDataLen = 0    #(WORD ExDataLen)
    ExData = ""    #(String ExData)//ÆäËû×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AssistGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExData,_pos = CommFunc.ReadString(_lpData, _pos,self.ExDataLen)
        return _pos

    def Clear(self):
        self.AssistGUID = ""
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.MapID = 0
        self.LineID = 0
        self.NPCID = 0
        self.ExDataLen = 0
        self.ExData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.AssistGUID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteDWORD(data, self.LineID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteWORD(data, self.ExDataLen)
        data = CommFunc.WriteString(data, self.ExDataLen, self.ExData)
        return data

    def OutputString(self):
        DumpString = '''
                                AssistGUID:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                Job:%d,
                                LV:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                MapID:%d,
                                LineID:%d,
                                NPCID:%d,
                                ExDataLen:%d,
                                ExData:%s
                                '''\
                                %(
                                self.AssistGUID,
                                self.PlayerID,
                                self.PlayerName,
                                self.Job,
                                self.LV,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.MapID,
                                self.LineID,
                                self.NPCID,
                                self.ExDataLen,
                                self.ExData
                                )
        return DumpString


class  tagGCAssistInfoList(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    AssistInfoList = list()    #(vector<tagGCAssistInfo> AssistInfoList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAssistInfoList = tagGCAssistInfo()
            _pos = temAssistInfoList.ReadData(_lpData, _pos)
            self.AssistInfoList.append(temAssistInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x01
        self.Count = 0
        self.AssistInfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B0 03 ÕýÔÚ½øÐÐÖеÄЭÖú #tagGCAssistingInfo

class  tagGCAssistingInfo(Structure):
    Head = tagHead()
    AssistGUID = ""    #(char AssistGUID[40])//ЭÖúGUID
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x03
        self.AssistGUID = ""
        return

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

        return length

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

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


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


#------------------------------------------------------
# B0 08 ЭÖú½áÊø #tagGCAssistOver

class  tagGCAssistOver(Structure):
    Head = tagHead()
    IsTagPlayerReason = 0    #(BYTE IsTagPlayerReason)//ÊÇ·ñ·¢²¼·½Ô­Òò
    ReasonLen = 0    #(BYTE ReasonLen)
    Reason = ""    #(String Reason)//Ô­Òò
    AssistGUID = ""    #(char AssistGUID[40])//ЭÖúGUID
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.IsTagPlayerReason,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ReasonLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Reason,_pos = CommFunc.ReadString(_lpData, _pos,self.ReasonLen)
        self.AssistGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x08
        self.IsTagPlayerReason = 0
        self.ReasonLen = 0
        self.Reason = ""
        self.AssistGUID = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsTagPlayerReason)
        data = CommFunc.WriteBYTE(data, self.ReasonLen)
        data = CommFunc.WriteString(data, self.ReasonLen, self.Reason)
        data = CommFunc.WriteString(data, 40, self.AssistGUID)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                IsTagPlayerReason:%d,
                                ReasonLen:%d,
                                Reason:%s,
                                AssistGUID:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.IsTagPlayerReason,
                                self.ReasonLen,
                                self.Reason,
                                self.AssistGUID
                                )
        return DumpString


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


#------------------------------------------------------
# B0 06 ¿É½ÓÊÕЭÖú¸ÐлÀñÎï¸öÊý #tagGCCanGetAssistThanksGiftCount

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

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

    def GetLength(self):
        return sizeof(tagGCCanGetAssistThanksGiftCount)

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

    def OutputString(self):
        DumpString = '''// B0 06 ¿É½ÓÊÕЭÖú¸ÐлÀñÎï¸öÊý //tagGCCanGetAssistThanksGiftCount:
                                Cmd:%s,
                                SubCmd:%s,
                                CanGetCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CanGetCount
                                )
        return DumpString


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


#------------------------------------------------------
# B0 02 ɾ³ýЭÖú #tagGCClearAssist

class  tagGCClearAssist(Structure):
    Head = tagHead()
    AssistGUID = ""    #(char AssistGUID[40])//ЭÖúGUID
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x02
        self.AssistGUID = ""
        return

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

        return length

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

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


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


#------------------------------------------------------
#B0 26 ¼Ò×åÐüÉÍÈÎÎñÍê³ÉÇé¿ö #tagFamilyArrestOverStateInfo

class  tagFamilyArrestOverState(Structure):
    ID = 0    #(DWORD ID)//ÐüÉÍÈÎÎñID
    NameLen = 0    #(WORD NameLen)//Ãû×Ö³¤¶È
    Name = ""    #(String Name)//size = NameLen
    OverState = 0    #(DWORD OverState)//ÈÎÎñÍê³ÉÇé¿ö
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.OverState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ID = 0
        self.NameLen = 0
        self.Name = ""
        self.OverState = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ID)
        data = CommFunc.WriteWORD(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteDWORD(data, self.OverState)
        return data

    def OutputString(self):
        DumpString = '''
                                ID:%d,
                                NameLen:%d,
                                Name:%s,
                                OverState:%d
                                '''\
                                %(
                                self.ID,
                                self.NameLen,
                                self.Name,
                                self.OverState
                                )
        return DumpString


class  tagFamilyArrestOverStateInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    ArrestOverStateInfo = list()    #(vector<tagFamilyArrestOverState> ArrestOverStateInfo)///size = Count	
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temArrestOverStateInfo = tagFamilyArrestOverState()
            _pos = temArrestOverStateInfo.ReadData(_lpData, _pos)
            self.ArrestOverStateInfo.append(temArrestOverStateInfo)
        return _pos

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

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

        return length

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

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


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


#------------------------------------------------------
# B0 05 ½ÓÊÕЭÖú¸ÐлÀñÎïÔ¤ÀÀ #tagGCGetAssistThanksGiftPreview

class  tagGCGetAssistThanksGiftPreview(Structure):
    Head = tagHead()
    ItemID = 0    #(DWORD ItemID)//ÀñºÐID
    PlayerID = 0    #(DWORD PlayerID)//·¢ÆðÍæ¼ÒID
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)
    RealmLV = 0    #(BYTE RealmLV)//¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    MapID = 0    #(DWORD MapID)
    LineID = 0    #(DWORD LineID)
    NPCID = 0    #(DWORD NPCID)
    ExDataLen = 0    #(WORD ExDataLen)
    ExData = ""    #(String ExData)//ÆäËû×Ô¶¨ÒåÊý¾Ý
    TimeStr = ""    #(char TimeStr[19])//ЭÖúʱ¼äyyyy-MM-dd hh:mm:ss
    ExtraAward = 0    #(BYTE ExtraAward)//ÊÇ·ñÓжîÍâ½±Àø
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExData,_pos = CommFunc.ReadString(_lpData, _pos,self.ExDataLen)
        self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.ExtraAward,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x05
        self.ItemID = 0
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.MapID = 0
        self.LineID = 0
        self.NPCID = 0
        self.ExDataLen = 0
        self.ExData = ""
        self.TimeStr = ""
        self.ExtraAward = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteDWORD(data, self.LineID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteWORD(data, self.ExDataLen)
        data = CommFunc.WriteString(data, self.ExDataLen, self.ExData)
        data = CommFunc.WriteString(data, 19, self.TimeStr)
        data = CommFunc.WriteBYTE(data, self.ExtraAward)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemID:%d,
                                PlayerID:%d,
                                PlayerName:%s,
                                Job:%d,
                                LV:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                MapID:%d,
                                LineID:%d,
                                NPCID:%d,
                                ExDataLen:%d,
                                ExData:%s,
                                TimeStr:%s,
                                ExtraAward:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemID,
                                self.PlayerID,
                                self.PlayerName,
                                self.Job,
                                self.LV,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.MapID,
                                self.LineID,
                                self.NPCID,
                                self.ExDataLen,
                                self.ExData,
                                self.TimeStr,
                                self.ExtraAward
                                )
        return DumpString


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


#------------------------------------------------------
# B0 34 ¸£µØ½áËã½±ÀøÐÅÏ¢ #tagGCMineAreaAwardInfo

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)
    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.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.MineCount = 0
        self.MineItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 33
        length += 1
        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.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,
                                MineCount:%d,
                                MineItemList:%s
                                '''\
                                %(
                                self.PlayerID,
                                self.PlayerName,
                                self.Job,
                                self.Face,
                                self.FacePic,
                                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):
    _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),    # Ô¤¼ÆÐèҪʱ¼ä£¬Ãë
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB0
        self.SubCmd = 0x32
        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 = 0x32
        self.PlayerID = 0
        self.ItemIndex = 0
        self.WorkerCount = 0
        self.NeedSeconds = 0
        return

    def GetLength(self):
        return sizeof(tagGCMineItemPullPreviewRet)

    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
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.ItemIndex,
                                self.WorkerCount,
                                self.NeedSeconds
                                )
        return DumpString


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


#------------------------------------------------------
# B0 04 ʹÓÃЭÖú¸ÐлÀñºÐÔ¤ÀÀ #tagGCUseAssistThanksGiftPreview

class  tagGCAssistPlayerInfo(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)
    RealmLV = 0    #(BYTE RealmLV)//¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCUseAssistThanksGiftPreview(Structure):
    Head = tagHead()
    ItemID = 0    #(DWORD ItemID)//ÀñºÐID
    MapID = 0    #(DWORD MapID)
    LineID = 0    #(DWORD LineID)
    NPCID = 0    #(DWORD NPCID)
    ExDataLen = 0    #(WORD ExDataLen)
    ExData = ""    #(String ExData)//ÆäËû×Ô¶¨ÒåÊý¾Ý
    AssistPlayerCount = 0    #(BYTE AssistPlayerCount)
    AssistPlayerList = list()    #(vector<tagGCAssistPlayerInfo> AssistPlayerList)//ЭÖúÍæ¼ÒÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExData,_pos = CommFunc.ReadString(_lpData, _pos,self.ExDataLen)
        self.AssistPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AssistPlayerCount):
            temAssistPlayerList = tagGCAssistPlayerInfo()
            _pos = temAssistPlayerList.ReadData(_lpData, _pos)
            self.AssistPlayerList.append(temAssistPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x04
        self.ItemID = 0
        self.MapID = 0
        self.LineID = 0
        self.NPCID = 0
        self.ExDataLen = 0
        self.ExData = ""
        self.AssistPlayerCount = 0
        self.AssistPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 4
        length += 2
        length += len(self.ExData)
        length += 1
        for i in range(self.AssistPlayerCount):
            length += self.AssistPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteDWORD(data, self.LineID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteWORD(data, self.ExDataLen)
        data = CommFunc.WriteString(data, self.ExDataLen, self.ExData)
        data = CommFunc.WriteBYTE(data, self.AssistPlayerCount)
        for i in range(self.AssistPlayerCount):
            data = CommFunc.WriteString(data, self.AssistPlayerList[i].GetLength(), self.AssistPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemID:%d,
                                MapID:%d,
                                LineID:%d,
                                NPCID:%d,
                                ExDataLen:%d,
                                ExData:%s,
                                AssistPlayerCount:%d,
                                AssistPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemID,
                                self.MapID,
                                self.LineID,
                                self.NPCID,
                                self.ExDataLen,
                                self.ExData,
                                self.AssistPlayerCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B0 20 Ĥ°ÝÐÅÏ¢Áбí #tagGCWorshipInfoList

class  tagGCWorshipInfo(Structure):
    PlayerID = 0    #(DWORD PlayerID)// Ä¿±êÍæ¼ÒID
    WorshipType = 0    #(BYTE WorshipType)// Ĥ°ÝÀàÐÍ
    WorshipValue = 0    #(DWORD WorshipValue)// Ĥ°ÝÀàÐͶÔÓ¦µÄ¹¦ÄÜÖµ£¬ÈçÃû´Î»òÆäËû£¬ÓɾßÌåĤ°ÝÀàÐͶ¨Òå¶ÔÓ¦Öµº¬Òå
    InfoLen = 0    #(WORD InfoLen)
    PlayerInfo = ""    #(String PlayerInfo)// Íæ¼ÒÐÅÏ¢{k:v, ...}
    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.WorshipType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WorshipValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.InfoLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PlayerInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.InfoLen)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.WorshipType = 0
        self.WorshipValue = 0
        self.InfoLen = 0
        self.PlayerInfo = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.WorshipType)
        data = CommFunc.WriteDWORD(data, self.WorshipValue)
        data = CommFunc.WriteWORD(data, self.InfoLen)
        data = CommFunc.WriteString(data, self.InfoLen, self.PlayerInfo)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                WorshipType:%d,
                                WorshipValue:%d,
                                InfoLen:%d,
                                PlayerInfo:%s
                                '''\
                                %(
                                self.PlayerID,
                                self.WorshipType,
                                self.WorshipValue,
                                self.InfoLen,
                                self.PlayerInfo
                                )
        return DumpString


class  tagGCWorshipInfoList(Structure):
    Head = tagHead()
    WorshipCount = 0    #(BYTE WorshipCount)
    WorshipInfoList = list()    #(vector<tagGCWorshipInfo> WorshipInfoList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.WorshipCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WorshipCount):
            temWorshipInfoList = tagGCWorshipInfo()
            _pos = temWorshipInfoList.ReadData(_lpData, _pos)
            self.WorshipInfoList.append(temWorshipInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x20
        self.WorshipCount = 0
        self.WorshipInfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B0 21 Ĥ°Ý½á¹û #tagGCWorshipResult

class  tagGCWorshipResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    # Ä¿±êÍæ¼ÒID
                  ("WorshipType", c_ubyte),    # Ĥ°ÝÀàÐÍ
                  ("WorshipValue", c_int),    # Ĥ°ÝÀàÐͶÔÓ¦µÄ¹¦ÄÜÖµ£¬ÈçÃû´Î»òÆäËû£¬ÓɾßÌåĤ°ÝÀàÐͶ¨Òå¶ÔÓ¦Öµº¬Òå
                  ("Result", c_ubyte),    # Ĥ°Ý½á¹û£º0-³É¹¦£»1-²»´æÔÚ¸ÃĤ°ÝÀàÐÍ£»2-²»´æÔÚ¸ÃÄ¿±êĤ°Ý£»3-²»ÄÜĤ°Ý¸ÃÄ¿±ê£»
                  ("MoneyType", c_ubyte),    # »õ±ÒÀàÐÍ
                  ("MoneyValue", c_int),    # »õ±Ò½±Àø
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB0
        self.SubCmd = 0x21
        self.PlayerID = 0
        self.WorshipType = 0
        self.WorshipValue = 0
        self.Result = 0
        self.MoneyType = 0
        self.MoneyValue = 0
        return

    def GetLength(self):
        return sizeof(tagGCWorshipResult)

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

    def OutputString(self):
        DumpString = '''// B0 21 Ĥ°Ý½á¹û //tagGCWorshipResult:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                WorshipType:%d,
                                WorshipValue:%d,
                                Result:%d,
                                MoneyType:%d,
                                MoneyValue:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.WorshipType,
                                self.WorshipValue,
                                self.Result,
                                self.MoneyType,
                                self.MoneyValue
                                )
        return DumpString


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


#------------------------------------------------------
#B3 03 ѯÎÊÊÇ·ñÔÊÐíÌí¼ÓºÃÓÑ#tagGCFriendAskIfJoin

class  tagGCFriendAskIfJoin(Structure):
    Head = tagHead()
    AskID = 0    #(DWORD AskID)//ÇëÇóºÃÓѵÄÈË
    Name = ""    #(char Name[33])
    LV = 0    #(WORD LV)
    RealmLV = 0    #(WORD RealmLV)//¾³½çµÈ¼¶
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AskID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x03
        self.AskID = 0
        self.Name = ""
        self.LV = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.AskID)
        data = CommFunc.WriteString(data, 33, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AskID:%d,
                                Name:%s,
                                LV:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AskID,
                                self.Name,
                                self.LV,
                                self.RealmLV,
                                self.Face,
                                self.FacePic
                                )
        return DumpString


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


#------------------------------------------------------
# B3 24 ϲÌÇÁбí #tagGCCandyList

class  tagGCCandyInfo(Structure):
    PlayerIDA = 0    #(DWORD PlayerIDA)// Íæ¼ÒID - ÇëÇó·½
    NameALen = 0    #(BYTE NameALen)
    PlayerNameA = ""    #(String PlayerNameA)
    PlayerIDB = 0    #(DWORD PlayerIDB)// Íæ¼ÒID - ½ÓÊÜ·½
    NameBLen = 0    #(BYTE NameBLen)
    PlayerNameB = ""    #(String PlayerNameB)
    BridePriceID = 0    #(BYTE BridePriceID)// ƸÀñID
    MarryTime = 0    #(DWORD MarryTime)// ³ÉÇ×ʱ¼ä´Á£¬Ãë
    EndTime = 0    #(DWORD EndTime)// ½áÊøʱ¼ä´Á£¬Ãë
    Prosperity = 0    #(DWORD Prosperity)// µ±Ç°·±ÈÙ¶È
    FireworksTotalBuyCount = 0    #(BYTE FireworksTotalBuyCount)// ÑÌ»¨×ÜÒѹºÂò´ÎÊý
    FireworksPlayerBuyCount = 0    #(BYTE FireworksPlayerBuyCount)// ÑÌ»¨Íæ¼ÒÒѹºÂò´ÎÊý
    PlayerFreeEatCandyCount = 0    #(BYTE PlayerFreeEatCandyCount)// Íæ¼ÒÒÑÃâ·Ñ³Ô¸ÃϲÌÇ×Ü´ÎÊý£¬°üº¬Ãâ·Ñ´ÎÊý¡¢ÑÌ»¨ÔùËÍ´ÎÊý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerIDA,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameALen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerNameA,_pos = CommFunc.ReadString(_lpData, _pos,self.NameALen)
        self.PlayerIDB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameBLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerNameB,_pos = CommFunc.ReadString(_lpData, _pos,self.NameBLen)
        self.BridePriceID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Prosperity,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FireworksTotalBuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FireworksPlayerBuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerFreeEatCandyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerIDA = 0
        self.NameALen = 0
        self.PlayerNameA = ""
        self.PlayerIDB = 0
        self.NameBLen = 0
        self.PlayerNameB = ""
        self.BridePriceID = 0
        self.MarryTime = 0
        self.EndTime = 0
        self.Prosperity = 0
        self.FireworksTotalBuyCount = 0
        self.FireworksPlayerBuyCount = 0
        self.PlayerFreeEatCandyCount = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += len(self.PlayerNameA)
        length += 4
        length += 1
        length += len(self.PlayerNameB)
        length += 1
        length += 4
        length += 4
        length += 4
        length += 1
        length += 1
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerIDA)
        data = CommFunc.WriteBYTE(data, self.NameALen)
        data = CommFunc.WriteString(data, self.NameALen, self.PlayerNameA)
        data = CommFunc.WriteDWORD(data, self.PlayerIDB)
        data = CommFunc.WriteBYTE(data, self.NameBLen)
        data = CommFunc.WriteString(data, self.NameBLen, self.PlayerNameB)
        data = CommFunc.WriteBYTE(data, self.BridePriceID)
        data = CommFunc.WriteDWORD(data, self.MarryTime)
        data = CommFunc.WriteDWORD(data, self.EndTime)
        data = CommFunc.WriteDWORD(data, self.Prosperity)
        data = CommFunc.WriteBYTE(data, self.FireworksTotalBuyCount)
        data = CommFunc.WriteBYTE(data, self.FireworksPlayerBuyCount)
        data = CommFunc.WriteBYTE(data, self.PlayerFreeEatCandyCount)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerIDA:%d,
                                NameALen:%d,
                                PlayerNameA:%s,
                                PlayerIDB:%d,
                                NameBLen:%d,
                                PlayerNameB:%s,
                                BridePriceID:%d,
                                MarryTime:%d,
                                EndTime:%d,
                                Prosperity:%d,
                                FireworksTotalBuyCount:%d,
                                FireworksPlayerBuyCount:%d,
                                PlayerFreeEatCandyCount:%d
                                '''\
                                %(
                                self.PlayerIDA,
                                self.NameALen,
                                self.PlayerNameA,
                                self.PlayerIDB,
                                self.NameBLen,
                                self.PlayerNameB,
                                self.BridePriceID,
                                self.MarryTime,
                                self.EndTime,
                                self.Prosperity,
                                self.FireworksTotalBuyCount,
                                self.FireworksPlayerBuyCount,
                                self.PlayerFreeEatCandyCount
                                )
        return DumpString


class  tagGCCandyList(Structure):
    Head = tagHead()
    CandyCount = 0    #(WORD CandyCount)
    CandyInfoList = list()    #(vector<tagGCCandyInfo> CandyInfoList)// ¿É³ÔϲÌÇÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CandyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.CandyCount):
            temCandyInfoList = tagGCCandyInfo()
            _pos = temCandyInfoList.ReadData(_lpData, _pos)
            self.CandyInfoList.append(temCandyInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x24
        self.CandyCount = 0
        self.CandyInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.CandyCount):
            length += self.CandyInfoList[i].GetLength()

        return length

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

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


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


#------------------------------------------------------
# B3 19 ÷ÈÁ¦¹±Ï×°ñ #tagGCCharmOfferBillboardDataList

class  tagGCCharmOfferBillboardData(Structure):
    OrderIndex = 0    #(DWORD OrderIndex)//Ãû´ÎË÷Òý£¬0´ú±íµÚÒ»Ãû
    PlayerID = 0    #(DWORD PlayerID)// Íæ¼ÒID - ¹±Ï×Õß
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    CharmValue = 0    #(DWORD CharmValue)//¹±Ï×÷ÈÁ¦Öµ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.OrderIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.CharmValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.OrderIndex = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.CharmValue = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.OrderIndex)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteDWORD(data, self.CharmValue)
        return data

    def OutputString(self):
        DumpString = '''
                                OrderIndex:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                CharmValue:%d
                                '''\
                                %(
                                self.OrderIndex,
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.CharmValue
                                )
        return DumpString


class  tagGCCharmOfferBillboardDataList(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ÷ÈÁ¦Íæ¼ÒID
    QueryType = 0    #(BYTE QueryType)// ²é¿´ÀàÐÍ£º 1-×Ü°ñ£¬2-ÖÜ°ñ£¬3-ÈÕ°ñ
    DataCount = 0    #(BYTE DataCount)
    OfferBillboardDataList = list()    #(vector<tagGCCharmOfferBillboardData> OfferBillboardDataList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x19
        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.QueryType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.DataCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DataCount):
            temOfferBillboardDataList = tagGCCharmOfferBillboardData()
            _pos = temOfferBillboardDataList.ReadData(_lpData, _pos)
            self.OfferBillboardDataList.append(temOfferBillboardDataList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x19
        self.PlayerID = 0
        self.QueryType = 0
        self.DataCount = 0
        self.OfferBillboardDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        for i in range(self.DataCount):
            length += self.OfferBillboardDataList[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.QueryType)
        data = CommFunc.WriteBYTE(data, self.DataCount)
        for i in range(self.DataCount):
            data = CommFunc.WriteString(data, self.OfferBillboardDataList[i].GetLength(), self.OfferBillboardDataList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                QueryType:%d,
                                DataCount:%d,
                                OfferBillboardDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.QueryType,
                                self.DataCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B3 26 °éÂÂÐÅÏ¢ #tagGCCoupleInfo

class  tagGCCoupleInfo(Structure):
    Head = tagHead()
    CoupleID = 0    #(DWORD CoupleID)// °éÂÂÍæ¼ÒID£¬Ò»¶¨ÊǺÃÓÑ£¬Éç½»ÐÅÏ¢´ÓºÃÓÑϵͳÖлñÈ¡
    NameLen = 0    #(BYTE NameLen)
    CoupleName = ""    #(String CoupleName)
    NewMarryTime = 0    #(DWORD NewMarryTime)// лéʱ¼ä´Á£¬ Ã룬¼ÆËã½á»éÌìÊý°´¸Ãʱ¼ä¼ÆËã
    MarryTime = 0    #(DWORD MarryTime)// ×î½üÒ»´ÎÌáÇ׳ɹ¦Ê±¼ä´Á£¬ Ã룬¼ÆËã¿ÉÀë»éʱ¼ä°´¸Ãʱ¼ä¼ÆËã
    BridePriceState = 0    #(DWORD BridePriceState)// ƸÀñ״̬£¬°´Î»´æ´¢ÒѹºÂò´ÎÊý£¬Èç205´ú±íID1ÂòÁË5´Î£¬ID2ÂòÁË0´Î£¬ID3ÂòÁË2´Î£¬×î¸ß9´Î
    BreakRequestID = 0    #(DWORD BreakRequestID)// µ±Ç°ÇëÇóÖеĺÍÀëʱ¼ä´Á - ÇëÇó·½ID£¬0´ú±íûÈË·¢ÆðÇëÇó
    BreakRequestTime = 0    #(DWORD BreakRequestTime)// µ±Ç°ÇëÇóÖеĺÍÀëʱ¼ä´Á£¬ Ã룬ÓÃÓÚ¼ÆËãºÍÀë»ØÓ¦ÓÐЧÆÚ
    PlayerBreakRequestTime = 0    #(DWORD PlayerBreakRequestTime)// Íæ¼Ò×î½üÒ»´ÎºÍÀëÇëÇóʱ¼ä´Á£¬ Ã룬ÓÃÓÚ¼ÆËã×ÔÉíµÄÇëÇóºÍÀëCD
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CoupleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CoupleName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.NewMarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BridePriceState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BreakRequestID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BreakRequestTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerBreakRequestTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x26
        self.CoupleID = 0
        self.NameLen = 0
        self.CoupleName = ""
        self.NewMarryTime = 0
        self.MarryTime = 0
        self.BridePriceState = 0
        self.BreakRequestID = 0
        self.BreakRequestTime = 0
        self.PlayerBreakRequestTime = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.CoupleID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.CoupleName)
        data = CommFunc.WriteDWORD(data, self.NewMarryTime)
        data = CommFunc.WriteDWORD(data, self.MarryTime)
        data = CommFunc.WriteDWORD(data, self.BridePriceState)
        data = CommFunc.WriteDWORD(data, self.BreakRequestID)
        data = CommFunc.WriteDWORD(data, self.BreakRequestTime)
        data = CommFunc.WriteDWORD(data, self.PlayerBreakRequestTime)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CoupleID:%d,
                                NameLen:%d,
                                CoupleName:%s,
                                NewMarryTime:%d,
                                MarryTime:%d,
                                BridePriceState:%d,
                                BreakRequestID:%d,
                                BreakRequestTime:%d,
                                PlayerBreakRequestTime:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CoupleID,
                                self.NameLen,
                                self.CoupleName,
                                self.NewMarryTime,
                                self.MarryTime,
                                self.BridePriceState,
                                self.BreakRequestID,
                                self.BreakRequestTime,
                                self.PlayerBreakRequestTime
                                )
        return DumpString


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


#------------------------------------------------------
# B3 22 ÊÕµ½ÌáÇ×ÐÅÏ¢ #tagGCMarryReqInfo

class  tagGCMarryReqInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ͬһ¸öÍæ¼ÒID¶à´ÎÌáÇ×ʱ¿ÉÄÜͬ²½¶à´Î£¬Ç°¶Ë¸²¸ÇÊý¾Ý¼´¿É
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    BridePriceID = 0    #(BYTE BridePriceID)// ƸÀñID
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x22
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.BridePriceID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x22
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.BridePriceID = 0
        return

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

        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.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.BridePriceID)
        return data

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


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


#------------------------------------------------------
# B3 21 ÌáÇ×·¢Ëͳɹ¦ #tagGCMarryReqOK

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

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

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

    def Clear(self):
        self.Cmd = 0xB3
        self.SubCmd = 0x21
        return

    def GetLength(self):
        return sizeof(tagGCMarryReqOK)

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

    def OutputString(self):
        DumpString = '''// B3 21 ÌáÇ×·¢Ëͳɹ¦ //tagGCMarryReqOK:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


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


#------------------------------------------------------
# B3 23 ÌáÇ×»ØÓ¦½á¹û #tagGCMarryResponseRet

class  tagGCMarryResponseRet(Structure):
    Head = tagHead()
    PlayerIDA = 0    #(DWORD PlayerIDA)// Íæ¼ÒID - ÇëÇó·½
    NameALen = 0    #(BYTE NameALen)
    PlayerNameA = ""    #(String PlayerNameA)
    PlayerIDB = 0    #(DWORD PlayerIDB)// Íæ¼ÒID - ½ÓÊÜ·½
    NameBLen = 0    #(BYTE NameBLen)
    PlayerNameB = ""    #(String PlayerNameB)
    IsOK = 0    #(BYTE IsOK)// ÊÇ·ñͬÒ⣬0-·ñ£¬1-ÊÇ;  Èç¹ûͬÒâÔòË«·½¶¼»áÊÕµ½¸Ã°ü£¬¸ù¾ÝÍæ¼ÒIDÅжÏ×Ô¼ºÊÇÇëÇó»ò½ÓÊÜ·½£¬ÏÔʾ²»Í¬µÄͬÒâ½á¹û½çÃ棻²»Í¬ÒâÖ»ÓÐÇëÇó·½»áÊÕµ½
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerIDA,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameALen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerNameA,_pos = CommFunc.ReadString(_lpData, _pos,self.NameALen)
        self.PlayerIDB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameBLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerNameB,_pos = CommFunc.ReadString(_lpData, _pos,self.NameBLen)
        self.IsOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x23
        self.PlayerIDA = 0
        self.NameALen = 0
        self.PlayerNameA = ""
        self.PlayerIDB = 0
        self.NameBLen = 0
        self.PlayerNameB = ""
        self.IsOK = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerIDA)
        data = CommFunc.WriteBYTE(data, self.NameALen)
        data = CommFunc.WriteString(data, self.NameALen, self.PlayerNameA)
        data = CommFunc.WriteDWORD(data, self.PlayerIDB)
        data = CommFunc.WriteBYTE(data, self.NameBLen)
        data = CommFunc.WriteString(data, self.NameBLen, self.PlayerNameB)
        data = CommFunc.WriteBYTE(data, self.IsOK)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerIDA:%d,
                                NameALen:%d,
                                PlayerNameA:%s,
                                PlayerIDB:%d,
                                NameBLen:%d,
                                PlayerNameB:%s,
                                IsOK:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerIDA,
                                self.NameALen,
                                self.PlayerNameA,
                                self.PlayerIDB,
                                self.NameBLen,
                                self.PlayerNameB,
                                self.IsOK
                                )
        return DumpString


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


#------------------------------------------------------
# B3 25 Íæ¼Ò÷ÈÁ¦ÖµÐÅÏ¢ #tagGCPlayerCharmValueInfo

class  tagGCPlayerCharmValueInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CharmValueTotal", c_int),    #µ±Ç°÷ÈÁ¦Öµ - ×Ü
                  ("CharmValueWeek", c_int),    #µ±Ç°÷ÈÁ¦Öµ - ÖÜ
                  ("CharmValueDay", c_int),    #µ±Ç°÷ÈÁ¦Öµ - ÈÕ
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB3
        self.SubCmd = 0x25
        self.CharmValueTotal = 0
        self.CharmValueWeek = 0
        self.CharmValueDay = 0
        return

    def GetLength(self):
        return sizeof(tagGCPlayerCharmValueInfo)

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

    def OutputString(self):
        DumpString = '''// B3 25 Íæ¼Ò÷ÈÁ¦ÖµÐÅÏ¢ //tagGCPlayerCharmValueInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                CharmValueTotal:%d,
                                CharmValueWeek:%d,
                                CharmValueDay:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CharmValueTotal,
                                self.CharmValueWeek,
                                self.CharmValueDay
                                )
        return DumpString


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


#------------------------------------------------------
# B3 15 Ïà¹ØÍæ¼ÒÔÚÏß״̬±ä¸üͬ²½ #tagGCRelatedPlayerOnlineState

class  tagGCRelatedPlayerOnlineState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    # Ïà¹ØÍæ¼ÒID
                  ("OfflineValue", c_int),    # ÀëÏßÖµ£º0-ÔÚÏߣ»1-ÀëÏߣ»>1-ÉÏ´ÎÀëÏßʱ¼ä´Á£¬¿ÉÓÃÓÚ¼ÆËãÀëÏ߶à¾ÃÁË£»µ±È¡²»µ½Íæ¼ÒÐÅϢʱÓÃ1´ú±íÒÑÀëÏߣ»
                  ("IsCross", c_ubyte),    # ÊÇ·ñ¿ç·þͬ²½µÄ£¬Èç¹ûÊÇ¿ç·þÔòÀëÏßʱ¼ä¼ÆËãʱҪȡ¿ç·þ·þÎñÆ÷ʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x15
        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 = 0xB3
        self.SubCmd = 0x15
        self.PlayerID = 0
        self.OfflineValue = 0
        self.IsCross = 0
        return

    def GetLength(self):
        return sizeof(tagGCRelatedPlayerOnlineState)

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

    def OutputString(self):
        DumpString = '''// B3 15 Ïà¹ØÍæ¼ÒÔÚÏß״̬±ä¸üͬ²½ //tagGCRelatedPlayerOnlineState:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                OfflineValue:%d,
                                IsCross:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.OfflineValue,
                                self.IsCross
                                )
        return DumpString


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


#------------------------------------------------------
# B3 20 ËÍÀñÎï³É¹¦Í¨Öª #tagGCSendGiftsOKList

class  tagGCSendGiftsOK(Structure):
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// ÔùËÍ·½Íæ¼ÒÃû
    PlayerID = 0    #(DWORD PlayerID)// ÔùËÍ·½Íæ¼ÒID
    GiftNum = 0    #(WORD GiftNum)// ÔùËÍÀñÎï±àºÅ
    GiftCount = 0    #(DWORD GiftCount)// ÔùËÍÀñÎïÊýÁ¿
    SendTime = 0    #(DWORD SendTime)// ÔùËÍʱ¼ä´Á
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiftNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GiftCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SendTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.NameLen = 0
        self.Name = ""
        self.PlayerID = 0
        self.GiftNum = 0
        self.GiftCount = 0
        self.SendTime = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteWORD(data, self.GiftNum)
        data = CommFunc.WriteDWORD(data, self.GiftCount)
        data = CommFunc.WriteDWORD(data, self.SendTime)
        return data

    def OutputString(self):
        DumpString = '''
                                NameLen:%d,
                                Name:%s,
                                PlayerID:%d,
                                GiftNum:%d,
                                GiftCount:%d,
                                SendTime:%d
                                '''\
                                %(
                                self.NameLen,
                                self.Name,
                                self.PlayerID,
                                self.GiftNum,
                                self.GiftCount,
                                self.SendTime
                                )
        return DumpString


class  tagGCSendGiftsOKList(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    SendGiftsOKList = list()    #(vector<tagGCSendGiftsOK> SendGiftsOKList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temSendGiftsOKList = tagGCSendGiftsOK()
            _pos = temSendGiftsOKList.ReadData(_lpData, _pos)
            self.SendGiftsOKList.append(temSendGiftsOKList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x20
        self.Count = 0
        self.SendGiftsOKList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B3 14 Éç½»ÈËȺ°éÂÂÐÅÏ¢ #tagGCSocialCouples

class  tagGCSocialCouple(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PlayerID", c_int),    
                  ("CoupleID", c_int),    #°éÂÂID
                  ]

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

    def GetLength(self):
        return sizeof(tagGCSocialCouple)

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

    def OutputString(self):
        DumpString = '''// B3 14 Éç½»ÈËȺ°éÂÂÐÅÏ¢ //tagGCSocialCouples:
                                PlayerID:%d,
                                CoupleID:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.CoupleID
                                )
        return DumpString


class  tagGCSocialCouples(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    Player = list()    #(vector<tagGCSocialCouple> Player)//size = Count
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x14
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temPlayer = tagGCSocialCouple()
            _pos = temPlayer.ReadData(_lpData, _pos)
            self.Player.append(temPlayer)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x14
        self.Count = 0
        self.Player = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#B3 01 Ìí¼ÓÉç½»¶ÔÏó #tagGCAddSocialPlayer

class  tagGCAddSocialPlayer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GroupType", c_ubyte),    # ·Ö×é 1 ×î½üÁªÏµÈË 2 ºÃÓÑ 3 ³ðÈË 4 ºÚÃûµ¥
                  ("PlayerID", c_int),    
                  ("SortValue", c_int),    #×î½üÁªÏµÈ˺ͳðÈË°´Ê±¼äÅÅÐò
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x01
        return

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

    def Clear(self):
        self.Cmd = 0xB3
        self.SubCmd = 0x01
        self.GroupType = 0
        self.PlayerID = 0
        self.SortValue = 0
        return

    def GetLength(self):
        return sizeof(tagGCAddSocialPlayer)

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

    def OutputString(self):
        DumpString = '''//B3 01 Ìí¼ÓÉç½»¶ÔÏó //tagGCAddSocialPlayer:
                                Cmd:%s,
                                SubCmd:%s,
                                GroupType:%d,
                                PlayerID:%d,
                                SortValue:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GroupType,
                                self.PlayerID,
                                self.SortValue
                                )
        return DumpString


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


#------------------------------------------------------
#B3 09 »Ø¸´Íæ¼Ò¼ò¶ÌÐÅÏ¢ #tagGCAnswerPlayerShortInfo

class  tagGCAnswerPlayerShortInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç
    OnlineType = 0    #(BYTE OnlineType)//ÔÚÏß״̬£¬ 0 ²»ÔÚÏß 1ÔÚÏß
    IsInTeam = 0    #(BYTE IsInTeam)//ÊÇ·ñÓжÓÎé
    ServerGroupID = 0    #(DWORD ServerGroupID)//·þÎñÆ÷×éID
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OnlineType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsInTeam,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ServerGroupID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x09
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.OnlineType = 0
        self.IsInTeam = 0
        self.ServerGroupID = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteBYTE(data, self.OnlineType)
        data = CommFunc.WriteBYTE(data, self.IsInTeam)
        data = CommFunc.WriteDWORD(data, self.ServerGroupID)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                Job:%d,
                                LV:%d,
                                RealmLV:%d,
                                OnlineType:%d,
                                IsInTeam:%d,
                                ServerGroupID:%d,
                                Face:%d,
                                FacePic:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PlayerName,
                                self.Job,
                                self.LV,
                                self.RealmLV,
                                self.OnlineType,
                                self.IsInTeam,
                                self.ServerGroupID,
                                self.Face,
                                self.FacePic
                                )
        return DumpString


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


#------------------------------------------------------
#B3 02 ɾ³ýÉç½»¶ÔÏó #tagGCDelSocialPlayer

class  tagGCDelSocialPlayer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GroupType", c_ubyte),    # ·Ö×é 1 ×î½üÁªÏµÈË 2 ºÃÓÑ 3 ³ðÈË 4 ºÚÃûµ¥
                  ("PlayerID", c_int),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB3
        self.SubCmd = 0x02
        self.GroupType = 0
        self.PlayerID = 0
        return

    def GetLength(self):
        return sizeof(tagGCDelSocialPlayer)

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

    def OutputString(self):
        DumpString = '''//B3 02 ɾ³ýÉç½»¶ÔÏó //tagGCDelSocialPlayer:
                                Cmd:%s,
                                SubCmd:%s,
                                GroupType:%d,
                                PlayerID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GroupType,
                                self.PlayerID
                                )
        return DumpString


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


#------------------------------------------------------
#B3 04 Éç½»ÈËȺ»ù±¾ÐÅÏ¢ #tagGCSocialPlayers

class  tagGCSocialPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç
    OnlineType = 0    #(BYTE OnlineType)//0²»ÔÚÏß 1ÔÚÏß 2ÍÑ»úÔÚÏß
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OnlineType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.OnlineType = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteBYTE(data, self.OnlineType)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCSocialPlayers(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    Player = list()    #(vector<tagGCSocialPlayer> Player)//size = Count
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temPlayer = tagGCSocialPlayer()
            _pos = temPlayer.ReadData(_lpData, _pos)
            self.Player.append(temPlayer)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x04
        self.Count = 0
        self.Player = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#B3 08 ֪ͨÍæ¼Ò·Ö×éÐÅÏ¢ #tagGCGroupPlayers

class  tagGCGroupPlayer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PlayerID", c_int),    
                  ("SortValue", 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.SortValue = 0
        return

    def GetLength(self):
        return sizeof(tagGCGroupPlayer)

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

    def OutputString(self):
        DumpString = '''//B3 08 ֪ͨÍæ¼Ò·Ö×éÐÅÏ¢ //tagGCGroupPlayers:
                                PlayerID:%d,
                                SortValue:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.SortValue
                                )
        return DumpString


class  tagGCGroupPlayers(Structure):
    Head = tagHead()
    GroupType = 0    #(BYTE GroupType)// ·Ö×é 1 ×î½üÁªÏµÈË 2 ºÃÓÑ 3 ³ðÈË 4 ºÚÃûµ¥ 5Ç×ÃÜ×é
    Count = 0    #(WORD Count)
    Players = list()    #(vector<tagGCGroupPlayer> Players)//size = Count
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.GroupType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temPlayers = tagGCGroupPlayer()
            _pos = temPlayers.ReadData(_lpData, _pos)
            self.Players.append(temPlayers)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x08
        self.GroupType = 0
        self.Count = 0
        self.Players = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#B3 05 É罻ȦÄڹ㲥Íæ¼ÒÃû³Æ #tagGCSocialName

class  tagGCSocialName(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    Name = ""    #(char Name[33])
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x05
        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.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x05
        self.PlayerID = 0
        self.Name = ""
        return

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

        return length

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

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


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


#------------------------------------------------------
#B3 06 Éç½»Íæ¼ÒÔÚÏßÇé¿ö #tagGCSocialOnline

class  tagGCSocialOnline(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    
                  ("OnlineType", c_ubyte),    #0²»ÔÚÏß 1ÔÚÏß 2ÍÑ»úÔÚÏß
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x06
        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 = 0xB3
        self.SubCmd = 0x06
        self.PlayerID = 0
        self.OnlineType = 0
        return

    def GetLength(self):
        return sizeof(tagGCSocialOnline)

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

    def OutputString(self):
        DumpString = '''//B3 06 Éç½»Íæ¼ÒÔÚÏßÇé¿ö //tagGCSocialOnline:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                OnlineType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.OnlineType
                                )
        return DumpString


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


#------------------------------------------------------
#B3 07 Éç½»Íæ¼ÒÊôÐԹ㲥 #tagGCSocialRefreshType

class  tagGCSocialRefreshType(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    
                  ("RefreshType", c_ubyte),    #²Î¿¼CDBPlayerRefresh__	
                  ("Value", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x07
        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 = 0xB3
        self.SubCmd = 0x07
        self.PlayerID = 0
        self.RefreshType = 0
        self.Value = 0
        return

    def GetLength(self):
        return sizeof(tagGCSocialRefreshType)

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

    def OutputString(self):
        DumpString = '''//B3 07 Éç½»Íæ¼ÒÊôÐԹ㲥 //tagGCSocialRefreshType:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                RefreshType:%d,
                                Value:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.RefreshType,
                                self.Value
                                )
        return DumpString


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


#------------------------------------------------------
#B3 10 ÓïÒôÁÄÌì #tagGCVoiceChat

class  tagGCVoiceChat(Structure):
    Head = tagHead()
    ChannelType = 0    #(BYTE ChannelType)// 1 ÊÀ½ç 2 ÏÉÃË 3 ˽ÁÄ(ºÃÓÑ) 4 ¶ÓÎé 5 ÇøÓò	
    SrcNameLen = 0    #(BYTE SrcNameLen)
    SrcName = ""    #(String SrcName)//size = SrcNameLen
    PlayerID = 0    #(DWORD PlayerID)
    ToNameLen = 0    #(BYTE ToNameLen)
    ToName = ""    #(String ToName)//size = ToNameLen
    ToPlayerID = 0    #(DWORD ToPlayerID)
    Len = 0    #(WORD Len)
    Content = list()    #(vector<BYTE> Content)//size = Len
    ExtraValue = 0    #(DWORD ExtraValue)//¸½¼ÓÖµ
    Extras = ""    #(char Extras[256])//¸½¼ÓÖµÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ChannelType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SrcNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SrcName,_pos = CommFunc.ReadString(_lpData, _pos,self.SrcNameLen)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ToNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ToName,_pos = CommFunc.ReadString(_lpData, _pos,self.ToNameLen)
        self.ToPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Len):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.Content.append(value)
        self.ExtraValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,256)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x10
        self.ChannelType = 0
        self.SrcNameLen = 0
        self.SrcName = ""
        self.PlayerID = 0
        self.ToNameLen = 0
        self.ToName = ""
        self.ToPlayerID = 0
        self.Len = 0
        self.Content = list()
        self.ExtraValue = 0
        self.Extras = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += len(self.SrcName)
        length += 4
        length += 1
        length += len(self.ToName)
        length += 4
        length += 2
        length += 1 * self.Len
        length += 4
        length += 256

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ChannelType)
        data = CommFunc.WriteBYTE(data, self.SrcNameLen)
        data = CommFunc.WriteString(data, self.SrcNameLen, self.SrcName)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.ToNameLen)
        data = CommFunc.WriteString(data, self.ToNameLen, self.ToName)
        data = CommFunc.WriteDWORD(data, self.ToPlayerID)
        data = CommFunc.WriteWORD(data, self.Len)
        for i in range(self.Len):
            data = CommFunc.WriteBYTE(data, self.Content[i])
        data = CommFunc.WriteDWORD(data, self.ExtraValue)
        data = CommFunc.WriteString(data, 256, self.Extras)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ChannelType:%d,
                                SrcNameLen:%d,
                                SrcName:%s,
                                PlayerID:%d,
                                ToNameLen:%d,
                                ToName:%s,
                                ToPlayerID:%d,
                                Len:%d,
                                Content:%s,
                                ExtraValue:%d,
                                Extras:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ChannelType,
                                self.SrcNameLen,
                                self.SrcName,
                                self.PlayerID,
                                self.ToNameLen,
                                self.ToName,
                                self.ToPlayerID,
                                self.Len,
                                "...",
                                self.ExtraValue,
                                self.Extras
                                )
        return DumpString


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


#------------------------------------------------------
# B3 11 ÁÄÌ컺´æ֪ͨ #tagGCTalkCache

class  tagGCTalkCacheInfo(Structure):
    ChannelType = 0    #(BYTE ChannelType)// 1 ÊÀ½ç 2 ÏÉÃË
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//size = SrcNameLen
    PlayerID = 0    #(DWORD PlayerID)
    Time = 0    #(DWORD Time)
    Len = 0    #(WORD Len)
    Content = ""    #(String Content)//size = Len
    Extras = ""    #(char Extras[256])//¸½¼ÓÖµÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ChannelType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Content,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,256)
        return _pos

    def Clear(self):
        self.ChannelType = 0
        self.NameLen = 0
        self.Name = ""
        self.PlayerID = 0
        self.Time = 0
        self.Len = 0
        self.Content = ""
        self.Extras = ""
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += len(self.Name)
        length += 4
        length += 4
        length += 2
        length += len(self.Content)
        length += 256

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ChannelType)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteDWORD(data, self.Time)
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.Content)
        data = CommFunc.WriteString(data, 256, self.Extras)
        return data

    def OutputString(self):
        DumpString = '''
                                ChannelType:%d,
                                NameLen:%d,
                                Name:%s,
                                PlayerID:%d,
                                Time:%d,
                                Len:%d,
                                Content:%s,
                                Extras:%s
                                '''\
                                %(
                                self.ChannelType,
                                self.NameLen,
                                self.Name,
                                self.PlayerID,
                                self.Time,
                                self.Len,
                                self.Content,
                                self.Extras
                                )
        return DumpString


class  tagGCTalkCache(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    InfoList = list()    #(vector<tagGCTalkCacheInfo> InfoList)//size = Count
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB3
        self.Head.SubCmd = 0x11
        self.Count = 0
        self.InfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 04 ÅÄÂôÐÐÐÂÉϼÜÅÄÆ· #tagGCAddAuctionItemInfo

class  tagGCAddAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    ItemID = 0    #(DWORD ItemID)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.ItemID = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                ItemID:%d
                                '''\
                                %(
                                self.ItemGUID,
                                self.ItemID
                                )
        return DumpString


class  tagGCAddAuctionItemInfo(Structure):
    Head = tagHead()
    AddCount = 0    #(BYTE AddCount)
    AddAuctionItemList = list()    #(vector<tagGCAddAuctionItem> AddAuctionItemList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AddCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AddCount):
            temAddAuctionItemList = tagGCAddAuctionItem()
            _pos = temAddAuctionItemList.ReadData(_lpData, _pos)
            self.AddAuctionItemList.append(temAddAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x04
        self.AddCount = 0
        self.AddAuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 07 ÅÄÂôÐйØ×¢µÄÎïÆ·ID #tagGCAttentionAuctionItemID

class  tagGCAttentionAuctionItemID(Structure):
    Head = tagHead()
    AttentionCount = 0    #(BYTE AttentionCount)
    AttentionItemIDList = list()    #(vector<DWORD> AttentionItemIDList)// ¹Ø×¢µÄÎïÆ·IDÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x07
        return

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x07
        self.AttentionCount = 0
        self.AttentionItemIDList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 06 ÅÄÂôÐйØ×¢ÖеÄÅÄÆ·ÐÅÏ¢ #tagGCAttentionAuctionItemInfo

class  tagGCAttentionAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderPrice = 0    #(DWORD BidderPrice)//¾ºÅÄÍæ¼Ò³ö¼Û
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.AddTime = ""
        self.BidderPrice = 0
        self.BiddingTime = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                AddTime:%s,
                                BidderPrice:%d,
                                BiddingTime:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.ItemID,
                                self.ItemCount,
                                self.AddTime,
                                self.BidderPrice,
                                self.BiddingTime,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCAttentionAuctionItemInfo(Structure):
    Head = tagHead()
    AuctionItemCount = 0    #(BYTE AuctionItemCount)//ÅÄÆ·ÊýÁ¿
    AuctionItemList = list()    #(vector<tagGCAttentionAuctionItem> AuctionItemList)//ÅÄÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AuctionItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AuctionItemCount):
            temAuctionItemList = tagGCAttentionAuctionItem()
            _pos = temAuctionItemList.ReadData(_lpData, _pos)
            self.AuctionItemList.append(temAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x06
        self.AuctionItemCount = 0
        self.AuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 01 ÅÄÂôÐÐÅÄÂôÖеÄÎïÆ·ÐÅÏ¢ #tagGCAuctionItemInfo

class  tagGCAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderPrice = 0    #(DWORD BidderPrice)//¾ºÅÄÍæ¼Ò³ö¼Û
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.AddTime = ""
        self.BidderPrice = 0
        self.BiddingTime = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                AddTime:%s,
                                BidderPrice:%d,
                                BiddingTime:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.ItemID,
                                self.ItemCount,
                                self.AddTime,
                                self.BidderPrice,
                                self.BiddingTime,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCAuctionItemInfo(Structure):
    Head = tagHead()
    Job = 0    #(BYTE Job)//¹ýÂËÖ°Òµ£¬0Ϊ²»ÏÞÖÆ
    ItemTypeCount = 0    #(BYTE ItemTypeCount)
    ItemTypeList = list()    #(vector<DWORD> ItemTypeList)//Ö¸¶¨µÄÎïÆ·ÀàÐÍ
    ClassLV = 0    #(BYTE ClassLV)//¹ýÂ˽×Êý£¬0Ϊ²»ÏÞÖÆ
    SpecItemIDCount = 0    #(BYTE SpecItemIDCount)//Ö¸¶¨ÎïÆ·ID¸öÊý
    SpecItemIDList = list()    #(vector<DWORD> SpecItemIDList)//Ö¸¶¨ÎïÆ·ID
    FromItemGUID = ""    #(char FromItemGUID[40])//´ÓÄĸöÎïÆ·¿ªÊ¼²éѯ
    QueryDir = 0    #(BYTE QueryDir)//²éѯ·½Ïò£¬1-Íùºó²é£¬2-ÍùÇ°²é£¬3-¶¨Î»²éѯ
    QueryCount = 0    #(BYTE QueryCount)//²éѯ¸öÊý£¬0Ϊȫ²¿
    QueryRemainlCount = 0    #(WORD QueryRemainlCount)//²éѯÌõ¼þ¶ÔÓ¦²éѯ·½ÏòÊ£Óà¸öÊý
    AuctionItemCount = 0    #(BYTE AuctionItemCount)//·µ»ØÅÄÆ·ÊýÁ¿
    AuctionItemList = list()    #(vector<tagGCAuctionItem> AuctionItemList)//·µ»ØÅÄÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x01
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemTypeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ItemTypeCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.ItemTypeList.append(value)
        self.ClassLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SpecItemIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SpecItemIDCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.SpecItemIDList.append(value)
        self.FromItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.QueryDir,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.QueryCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.QueryRemainlCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AuctionItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AuctionItemCount):
            temAuctionItemList = tagGCAuctionItem()
            _pos = temAuctionItemList.ReadData(_lpData, _pos)
            self.AuctionItemList.append(temAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x01
        self.Job = 0
        self.ItemTypeCount = 0
        self.ItemTypeList = list()
        self.ClassLV = 0
        self.SpecItemIDCount = 0
        self.SpecItemIDList = list()
        self.FromItemGUID = ""
        self.QueryDir = 0
        self.QueryCount = 0
        self.QueryRemainlCount = 0
        self.AuctionItemCount = 0
        self.AuctionItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4 * self.ItemTypeCount
        length += 1
        length += 1
        length += 4 * self.SpecItemIDCount
        length += 40
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.AuctionItemCount):
            length += self.AuctionItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.ItemTypeCount)
        for i in range(self.ItemTypeCount):
            data = CommFunc.WriteDWORD(data, self.ItemTypeList[i])
        data = CommFunc.WriteBYTE(data, self.ClassLV)
        data = CommFunc.WriteBYTE(data, self.SpecItemIDCount)
        for i in range(self.SpecItemIDCount):
            data = CommFunc.WriteDWORD(data, self.SpecItemIDList[i])
        data = CommFunc.WriteString(data, 40, self.FromItemGUID)
        data = CommFunc.WriteBYTE(data, self.QueryDir)
        data = CommFunc.WriteBYTE(data, self.QueryCount)
        data = CommFunc.WriteWORD(data, self.QueryRemainlCount)
        data = CommFunc.WriteBYTE(data, self.AuctionItemCount)
        for i in range(self.AuctionItemCount):
            data = CommFunc.WriteString(data, self.AuctionItemList[i].GetLength(), self.AuctionItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Job:%d,
                                ItemTypeCount:%d,
                                ItemTypeList:%s,
                                ClassLV:%d,
                                SpecItemIDCount:%d,
                                SpecItemIDList:%s,
                                FromItemGUID:%s,
                                QueryDir:%d,
                                QueryCount:%d,
                                QueryRemainlCount:%d,
                                AuctionItemCount:%d,
                                AuctionItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Job,
                                self.ItemTypeCount,
                                "...",
                                self.ClassLV,
                                self.SpecItemIDCount,
                                "...",
                                self.FromItemGUID,
                                self.QueryDir,
                                self.QueryCount,
                                self.QueryRemainlCount,
                                self.AuctionItemCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B5 10 ÅÄÂôÐÐÍæ¼Ò¾º¼ÛÖеÄÎïÆ·ÐÅÏ¢ #tagGCBiddingItemInfo

class  tagGCBiddingItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderID = 0    #(DWORD BidderID)//¾ºÅÄÍæ¼ÒID£¬Ò²¾ÍÊǵ±Ç°×î¸ß¾º¼ÛÍæ¼ÒID
    BidderPrice = 0    #(DWORD BidderPrice)//¾ºÅÄÍæ¼Ò³ö¼Û
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.AddTime = ""
        self.BidderID = 0
        self.BidderPrice = 0
        self.BiddingTime = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderID)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                AddTime:%s,
                                BidderID:%d,
                                BidderPrice:%d,
                                BiddingTime:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.ItemID,
                                self.ItemCount,
                                self.AddTime,
                                self.BidderID,
                                self.BidderPrice,
                                self.BiddingTime,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCBiddingItemInfo(Structure):
    Head = tagHead()
    AuctionItemCount = 0    #(BYTE AuctionItemCount)//ÅÄÆ·ÊýÁ¿
    AuctionItemList = list()    #(vector<tagGCBiddingItem> AuctionItemList)//ÅÄÆ·Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AuctionItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AuctionItemCount):
            temAuctionItemList = tagGCBiddingItem()
            _pos = temAuctionItemList.ReadData(_lpData, _pos)
            self.AuctionItemList.append(temAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x10
        self.AuctionItemCount = 0
        self.AuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 09 ÅÄÂôÐÐÇå³ýÅÄÆ· #tagGCClearAuctionItemInfo

class  tagGCClearAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        return

    def GetLength(self):
        length = 0
        length += 40

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s
                                '''\
                                %(
                                self.ItemGUID
                                )
        return DumpString


class  tagGCClearAuctionItemInfo(Structure):
    Head = tagHead()
    ClearCount = 0    #(BYTE ClearCount)
    ClearAuctionItemList = list()    #(vector<tagGCClearAuctionItem> ClearAuctionItemList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ClearCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ClearCount):
            temClearAuctionItemList = tagGCClearAuctionItem()
            _pos = temClearAuctionItemList.ReadData(_lpData, _pos)
            self.ClearAuctionItemList.append(temClearAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x09
        self.ClearCount = 0
        self.ClearAuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 11 ²¿Î»ÉýÐÇ×Ô¶¯¹ºÂòÅÄÆ·ÏûºÄÐÅÏ¢ #tagGCEquipStarAutoBuyCostInfo

class  tagGCEquipStarAutoBuyCostInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ClassLV", c_ubyte),    # µ±Ç°ÒªÉýÐǵľ³½ç½×
                  ("EquipPlace", c_ubyte),    #µ±Ç°ÒªÉýÐǵÄ×°±¸Î»
                  ("CurStar", c_ubyte),    #µ±Ç°ÐǼ¶
                  ("CurRate", c_ubyte),    #µ±Ç°×Ô¶¯¹ºÂòºóµÄ×ܸÅÂÊ£¬²»Âú100Ôò´ú±íÅÄÆ·¿â´æ²»×ã
                  ("AutoBuyCostMoney", c_int),    #×Ô¶¯¹ºÂòËùÐè×ÜÏûºÄ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB5
        self.SubCmd = 0x11
        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 = 0xB5
        self.SubCmd = 0x11
        self.ClassLV = 0
        self.EquipPlace = 0
        self.CurStar = 0
        self.CurRate = 0
        self.AutoBuyCostMoney = 0
        return

    def GetLength(self):
        return sizeof(tagGCEquipStarAutoBuyCostInfo)

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

    def OutputString(self):
        DumpString = '''// B5 11 ²¿Î»ÉýÐÇ×Ô¶¯¹ºÂòÅÄÆ·ÏûºÄÐÅÏ¢ //tagGCEquipStarAutoBuyCostInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ClassLV:%d,
                                EquipPlace:%d,
                                CurStar:%d,
                                CurRate:%d,
                                AutoBuyCostMoney:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ClassLV,
                                self.EquipPlace,
                                self.CurStar,
                                self.CurRate,
                                self.AutoBuyCostMoney
                                )
        return DumpString


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


#------------------------------------------------------
# B5 05 ÅÄÂôÐÐÏÉÃËÅÄÂôÖеÄÎïÆ·ÐÅÏ¢ #tagGCFamilyAuctionItemInfo

class  tagGCFamilyAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderPrice = 0    #(DWORD BidderPrice)//¾ºÅÄÍæ¼Ò³ö¼Û
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    FamilyPlayerIDLen = 0    #(WORD FamilyPlayerIDLen)
    FamilyPlayerIDInfo = ""    #(String FamilyPlayerIDInfo)//¿É»ñµÃÊÕÒæµÄÏÉÃËÍæ¼ÒIDÐÅÏ¢
    AuctionType = 0    #(BYTE AuctionType)//ÅÄÆ·ÀàÐÍ£¬0-È«·þÅÄÆ·£¬1-ÏÉÃËÅÄÆ·
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        self.FamilyPlayerIDLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FamilyPlayerIDInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.FamilyPlayerIDLen)
        self.AuctionType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.AddTime = ""
        self.BidderPrice = 0
        self.BiddingTime = ""
        self.UserDataLen = 0
        self.UserData = ""
        self.FamilyPlayerIDLen = 0
        self.FamilyPlayerIDInfo = ""
        self.AuctionType = 0
        return

    def GetLength(self):
        length = 0
        length += 40
        length += 4
        length += 4
        length += 2
        length += 19
        length += 4
        length += 19
        length += 2
        length += len(self.UserData)
        length += 2
        length += len(self.FamilyPlayerIDInfo)
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        data = CommFunc.WriteWORD(data, self.FamilyPlayerIDLen)
        data = CommFunc.WriteString(data, self.FamilyPlayerIDLen, self.FamilyPlayerIDInfo)
        data = CommFunc.WriteBYTE(data, self.AuctionType)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                AddTime:%s,
                                BidderPrice:%d,
                                BiddingTime:%s,
                                UserDataLen:%d,
                                UserData:%s,
                                FamilyPlayerIDLen:%d,
                                FamilyPlayerIDInfo:%s,
                                AuctionType:%d
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.ItemID,
                                self.ItemCount,
                                self.AddTime,
                                self.BidderPrice,
                                self.BiddingTime,
                                self.UserDataLen,
                                self.UserData,
                                self.FamilyPlayerIDLen,
                                self.FamilyPlayerIDInfo,
                                self.AuctionType
                                )
        return DumpString


class  tagGCFamilyAuctionItemInfo(Structure):
    Head = tagHead()
    AuctionItemCount = 0    #(BYTE AuctionItemCount)//ÅÄÆ·ÊýÁ¿
    AuctionItemList = list()    #(vector<tagGCFamilyAuctionItem> AuctionItemList)//ÅÄÆ·Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AuctionItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AuctionItemCount):
            temAuctionItemList = tagGCFamilyAuctionItem()
            _pos = temAuctionItemList.ReadData(_lpData, _pos)
            self.AuctionItemList.append(temAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x05
        self.AuctionItemCount = 0
        self.AuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 02 ÅÄÂôÐÐÍæ¼ÒÅÄÂôÖеÄÎïÆ·ÐÅÏ¢ #tagGCPlayerAuctionItemInfo

class  tagGCPlayerAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderPrice = 0    #(DWORD BidderPrice)//¾ºÅÄÍæ¼Ò³ö¼Û
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.AddTime = ""
        self.BidderPrice = 0
        self.BiddingTime = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                AddTime:%s,
                                BidderPrice:%d,
                                BiddingTime:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.ItemID,
                                self.ItemCount,
                                self.AddTime,
                                self.BidderPrice,
                                self.BiddingTime,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCPlayerAuctionItemInfo(Structure):
    Head = tagHead()
    AuctionItemCount = 0    #(BYTE AuctionItemCount)//ÅÄÆ·ÊýÁ¿
    AuctionItemList = list()    #(vector<tagGCPlayerAuctionItem> AuctionItemList)//ÅÄÆ·Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AuctionItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AuctionItemCount):
            temAuctionItemList = tagGCPlayerAuctionItem()
            _pos = temAuctionItemList.ReadData(_lpData, _pos)
            self.AuctionItemList.append(temAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x02
        self.AuctionItemCount = 0
        self.AuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 03 ÅÄÂôÐÐÍæ¼ÒÅÄÂô¼Ç¼ #tagGCPlayerAuctionRecordInfo

class  tagGCPlayerAuctionRecord(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    FamilyID = 0    #(DWORD FamilyID)//ÓÐֵʱΪÏÉÃËÅÄÆ·
    RecordType = 0    #(BYTE RecordType)//¼Ç¼ÀàÐÍ 0-ÎÒµÄÅÄÆ·¼Ç¼ 1-ÏÉÃËÅÄÆ·¼Ç¼ 2-ÎҵľºÅļǼ
    RecordResult = 0    #(BYTE RecordResult)//¼Ç¼½á¹û 0-Á÷ÅÄ 1-ÅÄÂô³É½» 2-»ØÊÕ 3-¾º¼Û³É¹¦ 4-¾º¼Ûʧ°Ü
    RecordTime = ""    #(char RecordTime[19])//¼Ç¼ʱ¼ä yyyy-MM-dd hh:mm:ss
    BidderPrice = 0    #(DWORD BidderPrice)//³É½»¼Û¸ñ
    BidderName = ""    #(char BidderName[33])//³É½»Íæ¼ÒÃû
    ItemID = 0    #(DWORD ItemID)
    ItemCount = 0    #(WORD ItemCount)
    UserDataLen = 0    #(WORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RecordType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RecordResult,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RecordTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BidderName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.FamilyID = 0
        self.RecordType = 0
        self.RecordResult = 0
        self.RecordTime = ""
        self.BidderPrice = 0
        self.BidderName = ""
        self.ItemID = 0
        self.ItemCount = 0
        self.UserDataLen = 0
        self.UserData = ""
        return

    def GetLength(self):
        length = 0
        length += 40
        length += 4
        length += 1
        length += 1
        length += 19
        length += 4
        length += 33
        length += 4
        length += 2
        length += 2
        length += len(self.UserData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteBYTE(data, self.RecordType)
        data = CommFunc.WriteBYTE(data, self.RecordResult)
        data = CommFunc.WriteString(data, 19, self.RecordTime)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 33, self.BidderName)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                FamilyID:%d,
                                RecordType:%d,
                                RecordResult:%d,
                                RecordTime:%s,
                                BidderPrice:%d,
                                BidderName:%s,
                                ItemID:%d,
                                ItemCount:%d,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.FamilyID,
                                self.RecordType,
                                self.RecordResult,
                                self.RecordTime,
                                self.BidderPrice,
                                self.BidderName,
                                self.ItemID,
                                self.ItemCount,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCPlayerAuctionRecordInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    AuctionRecordList = list()    #(vector<tagGCPlayerAuctionRecord> AuctionRecordList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAuctionRecordList = tagGCPlayerAuctionRecord()
            _pos = temAuctionRecordList.ReadData(_lpData, _pos)
            self.AuctionRecordList.append(temAuctionRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x03
        self.Count = 0
        self.AuctionRecordList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B5 08 ÅÄÂôÐÐË¢ÐÂÅÄÆ· #tagGCRefreshAuctionItemInfo

class  tagGCRefreshAuctionItem(Structure):
    ItemGUID = ""    #(char ItemGUID[40])
    AuctionType = 0    #(BYTE AuctionType)//ÅÄÆ·ÀàÐÍ£¬0-È«·þÅÄÆ·£¬1-ÏÉÃËÅÄÆ·
    AddTime = ""    #(char AddTime[19])//ÉϼÜʱ¼ä
    BidderID = 0    #(DWORD BidderID)//×î¸ß¾ºÅÄÍæ¼ÒID£¬Ò²¾ÍÊǵ±Ç°×î¸ß¾º¼ÛÍæ¼ÒID	
    BidderPrice = 0    #(DWORD BidderPrice)//×î¸ß¾ºÅļ۸ñ
    BiddingTime = ""    #(char BiddingTime[19])//¾º¼Ûʱ¼ä yyyy-MM-dd hh:mm:ss
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.AuctionType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AddTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.BidderID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BidderPrice,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BiddingTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        return _pos

    def Clear(self):
        self.ItemGUID = ""
        self.AuctionType = 0
        self.AddTime = ""
        self.BidderID = 0
        self.BidderPrice = 0
        self.BiddingTime = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteBYTE(data, self.AuctionType)
        data = CommFunc.WriteString(data, 19, self.AddTime)
        data = CommFunc.WriteDWORD(data, self.BidderID)
        data = CommFunc.WriteDWORD(data, self.BidderPrice)
        data = CommFunc.WriteString(data, 19, self.BiddingTime)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemGUID:%s,
                                AuctionType:%d,
                                AddTime:%s,
                                BidderID:%d,
                                BidderPrice:%d,
                                BiddingTime:%s
                                '''\
                                %(
                                self.ItemGUID,
                                self.AuctionType,
                                self.AddTime,
                                self.BidderID,
                                self.BidderPrice,
                                self.BiddingTime
                                )
        return DumpString


class  tagGCRefreshAuctionItemInfo(Structure):
    Head = tagHead()
    RefreshCount = 0    #(BYTE RefreshCount)
    RefreshAuctionItemList = list()    #(vector<tagGCRefreshAuctionItem> RefreshAuctionItemList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RefreshCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RefreshCount):
            temRefreshAuctionItemList = tagGCRefreshAuctionItem()
            _pos = temRefreshAuctionItemList.ReadData(_lpData, _pos)
            self.RefreshAuctionItemList.append(temRefreshAuctionItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB5
        self.Head.SubCmd = 0x08
        self.RefreshCount = 0
        self.RefreshAuctionItemList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B9 13 ½øÈë×é¶Ó¸±±¾Ê§°ÜÔ­Òò #tagGCEnterTeamFBFailReason

class  tagGCEnterTeamFBFailReason(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MapID", c_int),    # ÇëÇó½øÈëµÄµØͼID
                  ("AskType", c_ubyte),    # ÇëÇóÀàÐÍ£º 0-Æ¥ÅäÇëÇó£»1-½øÈëÇëÇó
                  ("Reason", c_ubyte),    # ʧ°ÜÔ­Òò£º2-´ÎÊý²»×㣻3-½øÈëCDÖУ»6-ÃÅƱ²»×ã
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB9
        self.SubCmd = 0x13
        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 = 0xB9
        self.SubCmd = 0x13
        self.MapID = 0
        self.AskType = 0
        self.Reason = 0
        return

    def GetLength(self):
        return sizeof(tagGCEnterTeamFBFailReason)

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

    def OutputString(self):
        DumpString = '''// B9 13 ½øÈë×é¶Ó¸±±¾Ê§°ÜÔ­Òò //tagGCEnterTeamFBFailReason:
                                Cmd:%s,
                                SubCmd:%s,
                                MapID:%d,
                                AskType:%d,
                                Reason:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MapID,
                                self.AskType,
                                self.Reason
                                )
        return DumpString


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


#------------------------------------------------------
# B9 23 ¹¦ÄܶÓÎé½âÉ¢ #tagGCFuncTeamDissolve

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

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

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

    def Clear(self):
        self.Cmd = 0xB9
        self.SubCmd = 0x23
        self.TeamID = 0
        return

    def GetLength(self):
        return sizeof(tagGCFuncTeamDissolve)

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

    def OutputString(self):
        DumpString = '''// B9 23 ¹¦ÄܶÓÎé½âÉ¢ //tagGCFuncTeamDissolve:
                                Cmd:%s,
                                SubCmd:%s,
                                TeamID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.TeamID
                                )
        return DumpString


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


#------------------------------------------------------
# B9 22 ¹¦ÄܶÓÎéÁбí #tagGCFuncTeamList

class  tagGCFuncTeamMem(Structure):
    ServerID = 0    #(DWORD ServerID)
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    FightPower = 0    #(DWORD FightPower)// Õ½Á¦£¬ÇóÓàÒÚ
    FightPowerEx = 0    #(DWORD FightPowerEx)// Õ½Á¦£¬Õû³ýÒÚ
    Value1 = 0    #(DWORD Value1)//Öµ1
    Value2 = 0    #(DWORD Value2)//Öµ2
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_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.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ServerID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.Value1 = 0
        self.Value2 = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ServerID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        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.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        return data

    def OutputString(self):
        DumpString = '''
                                ServerID:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                FightPower:%d,
                                FightPowerEx:%d,
                                Value1:%d,
                                Value2:%d
                                '''\
                                %(
                                self.ServerID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.FightPower,
                                self.FightPowerEx,
                                self.Value1,
                                self.Value2
                                )
        return DumpString


class  tagGCFuncTeam(Structure):
    TeamID = 0    #(DWORD TeamID)
    CreateTime = 0    #(DWORD CreateTime)//´´½¨¶ÓÎéʱ¼ä´Á
    FuncMapEx = 0    #(DWORD FuncMapEx)//¹¦ÄܵØͼÀ©Õ¹£¬È粻ͬµÄ²ã¼¶
    NameLen = 0    #(BYTE NameLen)
    TeamName = ""    #(String TeamName)//¶ÓÎéÃû³Æ
    CaptainID = 0    #(DWORD CaptainID)//¶Ó³¤ID£¬¶ÓÎéServerIDÖ±½ÓÈ¡¶Ó³¤µÄServerID
    MinLV = 0    #(WORD MinLV)//×îµÍµÈ¼¶ÏÞÖÆ
    MinFightPower = 0    #(DWORD MinFightPower)//×îµÍÕ½Á¦ÏÞÖÆ£¬ÇóÓàÒÚ
    MinFightPowerEx = 0    #(DWORD MinFightPowerEx)//×îµÍÕ½Á¦ÏÞÖÆ£¬Õû³ýÒÚ
    ServerOnly = 0    #(BYTE ServerOnly)//ÊÇ·ñ½ö±¾·þÍæ¼Ò¿É¼ÓÈ룬0-·ñ£¬1-ÊÇ
    NeedCheck = 0    #(BYTE NeedCheck)//ÊÇ·ñÐèÒªÉóºË
    Value1 = 0    #(DWORD Value1)//Öµ1
    Value2 = 0    #(DWORD Value2)//Öµ2
    MemberCount = 0    #(BYTE MemberCount)
    MemberList = list()    #(vector<tagGCFuncTeamMem> MemberList)// ³ÉÔ±Áбí
    ApplyCount = 0    #(WORD ApplyCount)
    ApplyIDList = list()    #(vector<DWORD> ApplyIDList)// ÉêÇëÍæ¼ÒIDÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CreateTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TeamName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.CaptainID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MinFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MinFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedCheck,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MemberCount):
            temMemberList = tagGCFuncTeamMem()
            _pos = temMemberList.ReadData(_lpData, _pos)
            self.MemberList.append(temMemberList)
        self.ApplyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.ApplyCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.ApplyIDList.append(value)
        return _pos

    def Clear(self):
        self.TeamID = 0
        self.CreateTime = 0
        self.FuncMapEx = 0
        self.NameLen = 0
        self.TeamName = ""
        self.CaptainID = 0
        self.MinLV = 0
        self.MinFightPower = 0
        self.MinFightPowerEx = 0
        self.ServerOnly = 0
        self.NeedCheck = 0
        self.Value1 = 0
        self.Value2 = 0
        self.MemberCount = 0
        self.MemberList = list()
        self.ApplyCount = 0
        self.ApplyIDList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 4
        length += 1
        length += len(self.TeamName)
        length += 4
        length += 2
        length += 4
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.MemberCount):
            length += self.MemberList[i].GetLength()
        length += 2
        length += 4 * self.ApplyCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.TeamID)
        data = CommFunc.WriteDWORD(data, self.CreateTime)
        data = CommFunc.WriteDWORD(data, self.FuncMapEx)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.TeamName)
        data = CommFunc.WriteDWORD(data, self.CaptainID)
        data = CommFunc.WriteWORD(data, self.MinLV)
        data = CommFunc.WriteDWORD(data, self.MinFightPower)
        data = CommFunc.WriteDWORD(data, self.MinFightPowerEx)
        data = CommFunc.WriteBYTE(data, self.ServerOnly)
        data = CommFunc.WriteBYTE(data, self.NeedCheck)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        data = CommFunc.WriteBYTE(data, self.MemberCount)
        for i in range(self.MemberCount):
            data = CommFunc.WriteString(data, self.MemberList[i].GetLength(), self.MemberList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.ApplyCount)
        for i in range(self.ApplyCount):
            data = CommFunc.WriteDWORD(data, self.ApplyIDList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                TeamID:%d,
                                CreateTime:%d,
                                FuncMapEx:%d,
                                NameLen:%d,
                                TeamName:%s,
                                CaptainID:%d,
                                MinLV:%d,
                                MinFightPower:%d,
                                MinFightPowerEx:%d,
                                ServerOnly:%d,
                                NeedCheck:%d,
                                Value1:%d,
                                Value2:%d,
                                MemberCount:%d,
                                MemberList:%s,
                                ApplyCount:%d,
                                ApplyIDList:%s
                                '''\
                                %(
                                self.TeamID,
                                self.CreateTime,
                                self.FuncMapEx,
                                self.NameLen,
                                self.TeamName,
                                self.CaptainID,
                                self.MinLV,
                                self.MinFightPower,
                                self.MinFightPowerEx,
                                self.ServerOnly,
                                self.NeedCheck,
                                self.Value1,
                                self.Value2,
                                self.MemberCount,
                                "...",
                                self.ApplyCount,
                                "..."
                                )
        return DumpString


class  tagGCFuncTeamList(Structure):
    Head = tagHead()
    FuncMapID = 0    #(DWORD FuncMapID)// ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
    FuncMapEx = 0    #(DWORD FuncMapEx)// ¹¦ÄܵØͼÀ©Õ¹£¬È粻ͬµÄ²ã¼¶£¬0´ú±íËùÓÐ
    StartIndex = 0    #(DWORD StartIndex)// ²é¿´µÄÆðʼË÷Òý£¬ ĬÈÏ0
    QueryCnt = 0    #(BYTE QueryCnt)// ²é¿´ÌõÊý£¬Ä¬ÈÏ20£¬×î´ó²»³¬¹ý100
    HaveSpace = 0    #(BYTE HaveSpace)// ÊÇ·ñÖ»²é¿´ÓпÕλÖõĶÓÎé
    IDLimitType = 0    #(BYTE IDLimitType)// IDÏÞÖÆÀàÐÍ£º1-ͬÏÉÃ˶ӳ¤£»2-ͬServerGroupID¶Ó³¤£»3-ͬServerID¶Ó³¤
    SearchLen = 0    #(BYTE SearchLen)
    SearchMsg = ""    #(String SearchMsg)// Ö¸¶¨ËÑË÷ʱÓÐÓ㬿ÉËÑË÷Ö¸¶¨¶ÓÎéID»òÄ£ºýËÑË÷¶ÓÎéÃû³Æ£¬ËÑË÷ʱ·µ»Ø×î¶àQueryCnt¸öÊýµÄ¶ÓÎé
    LoopIndex = 0    #(DWORD LoopIndex)// ·þÎñÆ÷¼ìË÷µ½µÄË÷Òý£¬ÁбíÏÂÀ­Ê±ÏÂÒ»¸ö²éѯ°üµÄStartIndex´ÓÕâ¸öLoopIndex¿ªÊ¼
    TeamCount = 0    #(BYTE TeamCount)// Èç¹û·µ»ØµÄ¶ÓÎéÊýСÓÚQueryCnt£¬´ú±í·þÎñÆ÷ÒѾ­Ã»ÓÐÂú×ãÌõ¼þµÄ¶ÓÎéÁË£¬ÁбíÔÙÏÂÀ­Ê±²»ÔÙ·¢²éѯ°ü
    TeamList = list()    #(vector<tagGCFuncTeam> TeamList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.StartIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.QueryCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HaveSpace,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IDLimitType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SearchLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SearchMsg,_pos = CommFunc.ReadString(_lpData, _pos,self.SearchLen)
        self.LoopIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TeamCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TeamCount):
            temTeamList = tagGCFuncTeam()
            _pos = temTeamList.ReadData(_lpData, _pos)
            self.TeamList.append(temTeamList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x22
        self.FuncMapID = 0
        self.FuncMapEx = 0
        self.StartIndex = 0
        self.QueryCnt = 0
        self.HaveSpace = 0
        self.IDLimitType = 0
        self.SearchLen = 0
        self.SearchMsg = ""
        self.LoopIndex = 0
        self.TeamCount = 0
        self.TeamList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 1
        length += 1
        length += 1
        length += 1
        length += len(self.SearchMsg)
        length += 4
        length += 1
        for i in range(self.TeamCount):
            length += self.TeamList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.FuncMapID)
        data = CommFunc.WriteDWORD(data, self.FuncMapEx)
        data = CommFunc.WriteDWORD(data, self.StartIndex)
        data = CommFunc.WriteBYTE(data, self.QueryCnt)
        data = CommFunc.WriteBYTE(data, self.HaveSpace)
        data = CommFunc.WriteBYTE(data, self.IDLimitType)
        data = CommFunc.WriteBYTE(data, self.SearchLen)
        data = CommFunc.WriteString(data, self.SearchLen, self.SearchMsg)
        data = CommFunc.WriteDWORD(data, self.LoopIndex)
        data = CommFunc.WriteBYTE(data, self.TeamCount)
        for i in range(self.TeamCount):
            data = CommFunc.WriteString(data, self.TeamList[i].GetLength(), self.TeamList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FuncMapID:%d,
                                FuncMapEx:%d,
                                StartIndex:%d,
                                QueryCnt:%d,
                                HaveSpace:%d,
                                IDLimitType:%d,
                                SearchLen:%d,
                                SearchMsg:%s,
                                LoopIndex:%d,
                                TeamCount:%d,
                                TeamList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FuncMapID,
                                self.FuncMapEx,
                                self.StartIndex,
                                self.QueryCnt,
                                self.HaveSpace,
                                self.IDLimitType,
                                self.SearchLen,
                                self.SearchMsg,
                                self.LoopIndex,
                                self.TeamCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B9 20 ¹¦ÄܶÓÎéˢР#tagGCFuncTeamRefresh

class  tagGCFuncTeamRefreshApply(Structure):
    ServerID = 0    #(DWORD ServerID)
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    FightPower = 0    #(DWORD FightPower)// Õ½Á¦£¬ÇóÓàÒÚ
    FightPowerEx = 0    #(DWORD FightPowerEx)// Õ½Á¦£¬Õû³ýÒÚ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_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)
        return _pos

    def Clear(self):
        self.ServerID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ServerID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        return data

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


class  tagGCFuncTeamRefreshMem(Structure):
    ServerID = 0    #(DWORD ServerID)
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½ç
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    FightPower = 0    #(DWORD FightPower)// Õ½Á¦£¬ÇóÓàÒÚ
    FightPowerEx = 0    #(DWORD FightPowerEx)// Õ½Á¦£¬Õû³ýÒÚ
    OfflineValue = 0    #(DWORD OfflineValue)// ÀëÏßÖµ£º0-ÔÚÏߣ»1-ÀëÏߣ»>1-ÉÏ´ÎÀëÏßʱ¼ä´Á£¬¿ÉÓÃÓÚ¼ÆËãÀëÏ߶à¾ÃÁË£»µ±È¡²»µ½Íæ¼ÒÐÅϢʱÓÃ1´ú±íÒÑÀëÏߣ»
    Value1 = 0    #(DWORD Value1)//Öµ1
    Value2 = 0    #(DWORD Value2)//Öµ2
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_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.OfflineValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ServerID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.OfflineValue = 0
        self.Value1 = 0
        self.Value2 = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 1
        length += len(self.Name)
        length += 2
        length += 1
        length += 2
        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.ServerID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        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.OfflineValue)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        return data

    def OutputString(self):
        DumpString = '''
                                ServerID:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                FightPower:%d,
                                FightPowerEx:%d,
                                OfflineValue:%d,
                                Value1:%d,
                                Value2:%d
                                '''\
                                %(
                                self.ServerID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.FightPower,
                                self.FightPowerEx,
                                self.OfflineValue,
                                self.Value1,
                                self.Value2
                                )
        return DumpString


class  tagGCFuncTeamRefresh(Structure):
    Head = tagHead()
    TeamID = 0    #(DWORD TeamID)
    CreateTime = 0    #(DWORD CreateTime)//´´½¨¶ÓÎéʱ¼ä´Á
    FuncMapID = 0    #(DWORD FuncMapID)// ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
    FuncMapEx = 0    #(DWORD FuncMapEx)// ¹¦ÄܵØͼÀ©Õ¹£¬È粻ͬµÄ²ã¼¶
    NameLen = 0    #(BYTE NameLen)
    TeamName = ""    #(String TeamName)// ¶ÓÎéÃû³Æ
    CaptainID = 0    #(DWORD CaptainID)//¶Ó³¤ID£¬¶ÓÎéServerIDÖ±½ÓÈ¡¶Ó³¤µÄServerID
    MinLV = 0    #(WORD MinLV)//×îµÍµÈ¼¶ÏÞÖÆ
    MinFightPower = 0    #(DWORD MinFightPower)//×îµÍÕ½Á¦ÏÞÖÆ£¬ÇóÓàÒÚ
    MinFightPowerEx = 0    #(DWORD MinFightPowerEx)//×îµÍÕ½Á¦ÏÞÖÆ£¬Õû³ýÒÚ
    ServerOnly = 0    #(BYTE ServerOnly)//ÊÇ·ñ½ö±¾·þÍæ¼Ò¿É¼ÓÈ룬0-·ñ£¬1-ÊÇ
    NeedCheck = 0    #(BYTE NeedCheck)//ÊÇ·ñÐèÒªÉóºË
    Value1 = 0    #(DWORD Value1)//Öµ1
    Value2 = 0    #(DWORD Value2)//Öµ2
    MemberCount = 0    #(BYTE MemberCount)
    MemberList = list()    #(vector<tagGCFuncTeamRefreshMem> MemberList)// ³ÉÔ±Áбí
    ApplyCount = 0    #(WORD ApplyCount)
    ApplyIDList = list()    #(vector<DWORD> ApplyIDList)// ÉêÇëÍæ¼ÒIDÁбí
    ApplyInfoList = list()    #(vector<tagGCFuncTeamRefreshApply> ApplyInfoList)// ÉêÇëÍæ¼ÒÃ÷ϸÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CreateTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TeamName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.CaptainID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MinFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MinFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedCheck,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MemberCount):
            temMemberList = tagGCFuncTeamRefreshMem()
            _pos = temMemberList.ReadData(_lpData, _pos)
            self.MemberList.append(temMemberList)
        self.ApplyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.ApplyCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.ApplyIDList.append(value)
        for i in range(self.ApplyCount):
            temApplyInfoList = tagGCFuncTeamRefreshApply()
            _pos = temApplyInfoList.ReadData(_lpData, _pos)
            self.ApplyInfoList.append(temApplyInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x20
        self.TeamID = 0
        self.CreateTime = 0
        self.FuncMapID = 0
        self.FuncMapEx = 0
        self.NameLen = 0
        self.TeamName = ""
        self.CaptainID = 0
        self.MinLV = 0
        self.MinFightPower = 0
        self.MinFightPowerEx = 0
        self.ServerOnly = 0
        self.NeedCheck = 0
        self.Value1 = 0
        self.Value2 = 0
        self.MemberCount = 0
        self.MemberList = list()
        self.ApplyCount = 0
        self.ApplyIDList = list()
        self.ApplyInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        length += len(self.TeamName)
        length += 4
        length += 2
        length += 4
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.MemberCount):
            length += self.MemberList[i].GetLength()
        length += 2
        length += 4 * self.ApplyCount
        for i in range(self.ApplyCount):
            length += self.ApplyInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.TeamID)
        data = CommFunc.WriteDWORD(data, self.CreateTime)
        data = CommFunc.WriteDWORD(data, self.FuncMapID)
        data = CommFunc.WriteDWORD(data, self.FuncMapEx)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.TeamName)
        data = CommFunc.WriteDWORD(data, self.CaptainID)
        data = CommFunc.WriteWORD(data, self.MinLV)
        data = CommFunc.WriteDWORD(data, self.MinFightPower)
        data = CommFunc.WriteDWORD(data, self.MinFightPowerEx)
        data = CommFunc.WriteBYTE(data, self.ServerOnly)
        data = CommFunc.WriteBYTE(data, self.NeedCheck)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        data = CommFunc.WriteBYTE(data, self.MemberCount)
        for i in range(self.MemberCount):
            data = CommFunc.WriteString(data, self.MemberList[i].GetLength(), self.MemberList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.ApplyCount)
        for i in range(self.ApplyCount):
            data = CommFunc.WriteDWORD(data, self.ApplyIDList[i])
        for i in range(self.ApplyCount):
            data = CommFunc.WriteString(data, self.ApplyInfoList[i].GetLength(), self.ApplyInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TeamID:%d,
                                CreateTime:%d,
                                FuncMapID:%d,
                                FuncMapEx:%d,
                                NameLen:%d,
                                TeamName:%s,
                                CaptainID:%d,
                                MinLV:%d,
                                MinFightPower:%d,
                                MinFightPowerEx:%d,
                                ServerOnly:%d,
                                NeedCheck:%d,
                                Value1:%d,
                                Value2:%d,
                                MemberCount:%d,
                                MemberList:%s,
                                ApplyCount:%d,
                                ApplyIDList:%s,
                                ApplyInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TeamID,
                                self.CreateTime,
                                self.FuncMapID,
                                self.FuncMapEx,
                                self.NameLen,
                                self.TeamName,
                                self.CaptainID,
                                self.MinLV,
                                self.MinFightPower,
                                self.MinFightPowerEx,
                                self.ServerOnly,
                                self.NeedCheck,
                                self.Value1,
                                self.Value2,
                                self.MemberCount,
                                "...",
                                self.ApplyCount,
                                "...",
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B9 01 ÊÕµ½ÑûÇë¼ÓÈë¶ÓÎéÐÅÏ¢ #tagGCInviteJoinTeamInfo

class  tagGCInviteJoinTeamInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ·¢ÆðÑûÇëµÄÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// ·¢ÆðÑûÇëµÄÍæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    JobLevel = 0    #(BYTE JobLevel)// Íæ¼ÒÖ°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    TagMapID = 0    #(DWORD TagMapID)// Ä¿±êµØͼ
    TagMapEx = 0    #(WORD TagMapEx)// Ä¿±êµØͼÀ©Õ¹
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x01
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TagMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TagMapEx,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x01
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.TagMapID = 0
        self.TagMapEx = 0
        return

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

        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.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.TagMapID)
        data = CommFunc.WriteWORD(data, self.TagMapEx)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                JobLevel:%d,
                                RealmLV:%d,
                                TagMapID:%d,
                                TagMapEx:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.JobLevel,
                                self.RealmLV,
                                self.TagMapID,
                                self.TagMapEx
                                )
        return DumpString


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


#------------------------------------------------------
# B9 09 ×é¶ÓÄ¿±ê¶ÓÎéÐÅÏ¢Áбí #tagGCTagMapTeamList

class  tagGCTagMapTeam(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// ¶Ó³¤Ãû³Æ
    LV = 0    #(WORD LV)// ¶Ó³¤µÈ¼¶
    Job = 0    #(BYTE Job)// ¶Ó³¤Ö°Òµ
    JobLevel = 0    #(BYTE JobLevel)// ¶Ó³¤Ö°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// ¶Ó³¤¾³½çµÈ¼¶
    MemberCount = 0    #(BYTE MemberCount)// ¶ÓÎéÈËÊý
    ReqMinLV = 0    #(WORD ReqMinLV)// ¶ÓÔ±×îµÍµÈ¼¶ÏÞÖÆ
    ReqMaxLV = 0    #(WORD ReqMaxLV)// ¶ÓÔ±×î¸ßµÈ¼¶ÏÞÖÆ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ReqMinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ReqMaxLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.MemberCount = 0
        self.ReqMinLV = 0
        self.ReqMaxLV = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteBYTE(data, self.MemberCount)
        data = CommFunc.WriteWORD(data, self.ReqMinLV)
        data = CommFunc.WriteWORD(data, self.ReqMaxLV)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                LV:%d,
                                Job:%d,
                                JobLevel:%d,
                                RealmLV:%d,
                                MemberCount:%d,
                                ReqMinLV:%d,
                                ReqMaxLV:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.LV,
                                self.Job,
                                self.JobLevel,
                                self.RealmLV,
                                self.MemberCount,
                                self.ReqMinLV,
                                self.ReqMaxLV
                                )
        return DumpString


class  tagGCTagMapTeamList(Structure):
    Head = tagHead()
    TagMapID = 0    #(DWORD TagMapID)// Ä¿±êµØͼ
    TagMapEx = 0    #(WORD TagMapEx)// Ä¿±êµØͼÀ©Õ¹
    IsTagEx = 0    #(BYTE IsTagEx)// ÊÇ·ñ¶ÔӦĿ±êÀ©Õ¹µÄ; 0·ñ1ÊÇ
    MatchState = 0    #(BYTE MatchState)// 0-È«²¿£»1-Æ¥ÅäÖеģ»
    TeamCount = 0    #(BYTE TeamCount)
    TeamList = list()    #(vector<tagGCTagMapTeam> TeamList)// ¶ÓÎéÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x09
        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.IsTagEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MatchState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TeamCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TeamCount):
            temTeamList = tagGCTagMapTeam()
            _pos = temTeamList.ReadData(_lpData, _pos)
            self.TeamList.append(temTeamList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x09
        self.TagMapID = 0
        self.TagMapEx = 0
        self.IsTagEx = 0
        self.MatchState = 0
        self.TeamCount = 0
        self.TeamList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 1
        length += 1
        length += 1
        for i in range(self.TeamCount):
            length += self.TeamList[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.IsTagEx)
        data = CommFunc.WriteBYTE(data, self.MatchState)
        data = CommFunc.WriteBYTE(data, self.TeamCount)
        for i in range(self.TeamCount):
            data = CommFunc.WriteString(data, self.TeamList[i].GetLength(), self.TeamList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TagMapID:%d,
                                TagMapEx:%d,
                                IsTagEx:%d,
                                MatchState:%d,
                                TeamCount:%d,
                                TeamList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TagMapID,
                                self.TagMapEx,
                                self.IsTagEx,
                                self.MatchState,
                                self.TeamCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B9 21 ²éÕÒÍæ¼Ò¹¦ÄܶÓÎé½á¹û #tagGCQueryPlayerFuncTeamRet

class  tagGCQueryPlayerFuncTeamRet(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("FuncMapID", c_int),    # ¹¦ÄܵØͼID»ò×Ô¶¨ÒåµÄ»î¶¯¹¦ÄÜID
                  ("TeamID", c_int),    # Íæ¼ÒËùÊô¶ÓÎéID£¬Ä¿Ç°Ö»Í¬²½0µÄÇé¿ö£¬Èç¹ûÍæ¼ÒÓжÓÎéͳһB920·â°üͬ²½´¦Àí
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB9
        self.SubCmd = 0x21
        self.FuncMapID = 0
        self.TeamID = 0
        return

    def GetLength(self):
        return sizeof(tagGCQueryPlayerFuncTeamRet)

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

    def OutputString(self):
        DumpString = '''// B9 21 ²éÕÒÍæ¼Ò¹¦ÄܶÓÎé½á¹û //tagGCQueryPlayerFuncTeamRet:
                                Cmd:%s,
                                SubCmd:%s,
                                FuncMapID:%d,
                                TeamID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.FuncMapID,
                                self.TeamID
                                )
        return DumpString


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


#------------------------------------------------------
# B9 08 ÍƼö×é¶ÓµÄ¸½½üÍæ¼ÒÐÅÏ¢ #tagGCRecommendNearbyPlayerList

class  tagGCRecommendNearbyPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    JobLevel = 0    #(BYTE JobLevel)// Íæ¼ÒÖ°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCRecommendNearbyPlayerList(Structure):
    Head = tagHead()
    PlayerCount = 0    #(BYTE PlayerCount)
    PlayerList = list()    #(vector<tagGCRecommendNearbyPlayer> PlayerList)// ÍƼöÍæ¼ÒÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PlayerCount):
            temPlayerList = tagGCRecommendNearbyPlayer()
            _pos = temPlayerList.ReadData(_lpData, _pos)
            self.PlayerList.append(temPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x08
        self.PlayerCount = 0
        self.PlayerList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# B9 07 ÊÕµ½ÇëÇó¼ÓÈë¶ÓÎéÐÅÏ¢ #tagGCRequestJoinTeam

class  tagGCRequestJoinTeam(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ·¢ÆðÇëÇóµÄÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// ·¢ÆðÇëÇóµÄÍæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    JobLevel = 0    #(BYTE JobLevel)// Íæ¼ÒÖ°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x07
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x07
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                JobLevel:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.JobLevel,
                                self.RealmLV,
                                self.Face,
                                self.FacePic
                                )
        return DumpString


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


#------------------------------------------------------
# B9 04 ˢг¡¾°¶ÓÎé»ØÓ¦°ü #tagGCSceneTeamRefresh

class  tagGCSceneTeam(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// ¶Ó³¤Ãû³Æ
    LV = 0    #(WORD LV)// ¶Ó³¤µÈ¼¶
    Job = 0    #(BYTE Job)// ¶Ó³¤Ö°Òµ
    JobLevel = 0    #(BYTE JobLevel)// ¶Ó³¤Ö°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// ¶Ó³¤¾³½çµÈ¼¶
    MemberCount = 0    #(BYTE MemberCount)// ¶ÓÎéÈËÊý
    TagMapID = 0    #(DWORD TagMapID)// Ä¿±êµØͼ
    TagMapEx = 0    #(WORD TagMapEx)// Ä¿±êµØͼÀ©Õ¹
    ReqMinLV = 0    #(WORD ReqMinLV)// ¶ÓÔ±×îµÍµÈ¼¶ÏÞÖÆ
    ReqMaxLV = 0    #(WORD ReqMaxLV)// ¶ÓÔ±×î¸ßµÈ¼¶ÏÞÖÆ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TagMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TagMapEx,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ReqMinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ReqMaxLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.MemberCount = 0
        self.TagMapID = 0
        self.TagMapEx = 0
        self.ReqMinLV = 0
        self.ReqMaxLV = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteBYTE(data, self.MemberCount)
        data = CommFunc.WriteDWORD(data, self.TagMapID)
        data = CommFunc.WriteWORD(data, self.TagMapEx)
        data = CommFunc.WriteWORD(data, self.ReqMinLV)
        data = CommFunc.WriteWORD(data, self.ReqMaxLV)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                LV:%d,
                                Job:%d,
                                JobLevel:%d,
                                RealmLV:%d,
                                MemberCount:%d,
                                TagMapID:%d,
                                TagMapEx:%d,
                                ReqMinLV:%d,
                                ReqMaxLV:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.LV,
                                self.Job,
                                self.JobLevel,
                                self.RealmLV,
                                self.MemberCount,
                                self.TagMapID,
                                self.TagMapEx,
                                self.ReqMinLV,
                                self.ReqMaxLV
                                )
        return DumpString


class  tagGCSceneTeamRefresh(Structure):
    Head = tagHead()
    TeamCount = 0    #(BYTE TeamCount)
    SceneTeamList = list()    #(vector<tagGCSceneTeam> SceneTeamList)// ³¡¾°¶ÓÎéÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TeamCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TeamCount):
            temSceneTeamList = tagGCSceneTeam()
            _pos = temSceneTeamList.ReadData(_lpData, _pos)
            self.SceneTeamList.append(temSceneTeamList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x04
        self.TeamCount = 0
        self.SceneTeamList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# 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):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("TagMapID", c_int),    # Ä¿±êµØͼ
                  ("TagMapEx", c_ushort),    # Ä¿±êµØͼÀ©Õ¹
                  ("ReqMinLV", c_ushort),    # ¶ÓÔ±×îµÍµÈ¼¶ÏÞÖÆ
                  ("ReqMaxLV", c_ushort),    # ¶ÓÔ±×î¸ßµÈ¼¶ÏÞÖÆ
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB9
        self.SubCmd = 0x03
        self.TagMapID = 0
        self.TagMapEx = 0
        self.ReqMinLV = 0
        self.ReqMaxLV = 0
        return

    def GetLength(self):
        return sizeof(tagGCTeamInfoChange)

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

    def OutputString(self):
        DumpString = '''// B9 03 ¶ÓÎéÐÅÏ¢±ä¸ü //tagGCTeamInfoChange:
                                Cmd:%s,
                                SubCmd:%s,
                                TagMapID:%d,
                                TagMapEx:%d,
                                ReqMinLV:%d,
                                ReqMaxLV:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.TagMapID,
                                self.TagMapEx,
                                self.ReqMinLV,
                                self.ReqMaxLV
                                )
        return DumpString


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


#------------------------------------------------------
# B9 10 ¶ÓÎé»òÍæ¼ÒÆ¥Åä״̬±ä¸ü #tagGCTeamMatchState

class  tagGCTeamMatchState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsMatching", c_ubyte),    # ÊÇ·ñÆ¥ÅäÖÐ, 0·ñ1ÊÇ
                  ]

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

    def GetLength(self):
        return sizeof(tagGCTeamMatchState)

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

    def OutputString(self):
        DumpString = '''// B9 10 ¶ÓÎé»òÍæ¼ÒÆ¥Åä״̬±ä¸ü //tagGCTeamMatchState:
                                Cmd:%s,
                                SubCmd:%s,
                                IsMatching:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsMatching
                                )
        return DumpString


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


#------------------------------------------------------
# B9 02 ¶ÓÎé³ÉÔ±ÐÅϢˢР#tagGCTeamMemberInfo

class  tagGCTeamMember(Structure):
    Index = 0    #(BYTE Index)// ¶ÓÔ±±àºÅ
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    MemberLV = 0    #(BYTE MemberLV)// ³ÉÔ±µÈ¼¶, 0-ÆÕͨ³ÉÔ±, 2-¶Ó³¤
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ
    JobLevel = 0    #(BYTE JobLevel)// Íæ¼ÒÖ°Òµ½×¼¶
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    PlayerState = 0    #(BYTE PlayerState)// 0: ÀëÏß 1:ÔÚÏß
    MapID = 0    #(DWORD MapID)// µØͼID
    LineID = 0    #(BYTE LineID)// Ïß·ID
    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.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.MemberLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.JobLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Index = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.MemberLV = 0
        self.LV = 0
        self.Job = 0
        self.JobLevel = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.PlayerState = 0
        self.MapID = 0
        self.LineID = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Index)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteBYTE(data, self.MemberLV)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.JobLevel)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteBYTE(data, self.PlayerState)
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteBYTE(data, self.LineID)
        return data

    def OutputString(self):
        DumpString = '''
                                Index:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                MemberLV:%d,
                                LV:%d,
                                Job:%d,
                                JobLevel:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                PlayerState:%d,
                                MapID:%d,
                                LineID:%d
                                '''\
                                %(
                                self.Index,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.MemberLV,
                                self.LV,
                                self.Job,
                                self.JobLevel,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.PlayerState,
                                self.MapID,
                                self.LineID
                                )
        return DumpString


class  tagGCTeamMemberInfo(Structure):
    Head = tagHead()
    TeamID = 0    #(DWORD TeamID)
    TagMapID = 0    #(DWORD TagMapID)// Ä¿±êµØͼ
    TagMapEx = 0    #(WORD TagMapEx)// Ä¿±êµØͼÀ©Õ¹
    ReqMinLV = 0    #(WORD ReqMinLV)// ¶ÓÔ±×îµÍµÈ¼¶ÏÞÖÆ
    ReqMaxLV = 0    #(WORD ReqMaxLV)// ¶ÓÔ±×î¸ßµÈ¼¶ÏÞÖÆ
    MemberCount = 0    #(BYTE MemberCount)
    MemberList = list()    #(vector<tagGCTeamMember> MemberList)// ³ÉÔ±Áбí, size = MemberCount
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TagMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TagMapEx,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ReqMinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ReqMaxLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MemberCount):
            temMemberList = tagGCTeamMember()
            _pos = temMemberList.ReadData(_lpData, _pos)
            self.MemberList.append(temMemberList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB9
        self.Head.SubCmd = 0x02
        self.TeamID = 0
        self.TagMapID = 0
        self.TagMapEx = 0
        self.ReqMinLV = 0
        self.ReqMaxLV = 0
        self.MemberCount = 0
        self.MemberList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.TeamID)
        data = CommFunc.WriteDWORD(data, self.TagMapID)
        data = CommFunc.WriteWORD(data, self.TagMapEx)
        data = CommFunc.WriteWORD(data, self.ReqMinLV)
        data = CommFunc.WriteWORD(data, self.ReqMaxLV)
        data = CommFunc.WriteBYTE(data, self.MemberCount)
        for i in range(self.MemberCount):
            data = CommFunc.WriteString(data, self.MemberList[i].GetLength(), self.MemberList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TeamID:%d,
                                TagMapID:%d,
                                TagMapEx:%d,
                                ReqMinLV:%d,
                                ReqMaxLV:%d,
                                MemberCount:%d,
                                MemberList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TeamID,
                                self.TagMapID,
                                self.TagMapEx,
                                self.ReqMinLV,
                                self.ReqMaxLV,
                                self.MemberCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B9 05 ¶ÓÎé³ÉÔ±ÊôÐÔˢР#tagGCTeamMemberRefreshProperty

class  tagGCTeamMemberRefreshProperty(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    
                  ("RefreshType", c_ubyte),    #Ë¢ÐÂÀàÐÍ£¬Í¬0418ÊôÐÔÀàÐÍ
                  ("Value", c_int),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xB9
        self.SubCmd = 0x05
        self.PlayerID = 0
        self.RefreshType = 0
        self.Value = 0
        return

    def GetLength(self):
        return sizeof(tagGCTeamMemberRefreshProperty)

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

    def OutputString(self):
        DumpString = '''// B9 05 ¶ÓÎé³ÉÔ±ÊôÐÔˢР//tagGCTeamMemberRefreshProperty:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                RefreshType:%d,
                                Value:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.RefreshType,
                                self.Value
                                )
        return DumpString


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


#------------------------------------------------------
# C0 23 ¿ç·þÅÅλ¾º²Â¸öÈËÐÅÏ¢ #tagGCChampionshipGuessPriInfo

class  tagGCChampionshipGuessPlayerPri(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PlayerID", c_int),    # Ä¿±êÍæ¼ÒID
                  ("MoneyTotal", c_int),    # ÒÑͶע¸ÃÍæ¼Ò»õ±Ò×ÜÊý
                  ("GuessRank", c_ubyte),    # ¾º²ÂÃû´Î£¬Ã»ÓÐÃû´ÎµÄ¾º²ÂĬÈÏ0£»1-´ú±íµÚÒ»Ãû
                  ]

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

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

    def Clear(self):
        self.PlayerID = 0
        self.MoneyTotal = 0
        self.GuessRank = 0
        return

    def GetLength(self):
        return sizeof(tagGCChampionshipGuessPlayerPri)

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

    def OutputString(self):
        DumpString = '''// C0 23 ¿ç·þÅÅλ¾º²Â¸öÈËÐÅÏ¢ //tagGCChampionshipGuessPriInfo:
                                PlayerID:%d,
                                MoneyTotal:%d,
                                GuessRank:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.MoneyTotal,
                                self.GuessRank
                                )
        return DumpString


class  tagGCChampionshipGuessPriList(Structure):
    GuessType = 0    #(BYTE GuessType)//¾º²ÂÀàÐÍ 8-8Ç¿£»4-4Ç¿ÅÅλ
    PlayerCount = 0    #(BYTE PlayerCount)
    GuessPlayerList = list()    #(vector<tagGCChampionshipGuessPlayerPri> GuessPlayerList)// ±»¾º²ÂÍæ¼ÒÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GuessType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PlayerCount):
            temGuessPlayerList = tagGCChampionshipGuessPlayerPri()
            _pos = temGuessPlayerList.ReadData(_lpData, _pos)
            self.GuessPlayerList.append(temGuessPlayerList)
        return _pos

    def Clear(self):
        self.GuessType = 0
        self.PlayerCount = 0
        self.GuessPlayerList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.GuessType)
        data = CommFunc.WriteBYTE(data, self.PlayerCount)
        for i in range(self.PlayerCount):
            data = CommFunc.WriteString(data, self.GuessPlayerList[i].GetLength(), self.GuessPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GuessType:%d,
                                PlayerCount:%d,
                                GuessPlayerList:%s
                                '''\
                                %(
                                self.GuessType,
                                self.PlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCChampionshipGuessPriInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ÅÅλÊý¾Ý·ÖÇøID
    Count = 0    #(BYTE Count)
    GuessList = list()    #(vector<tagGCChampionshipGuessPriList> GuessList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temGuessList = tagGCChampionshipGuessPriList()
            _pos = temGuessList.ReadData(_lpData, _pos)
            self.GuessList.append(temGuessList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x23
        self.ZoneID = 0
        self.Count = 0
        self.GuessList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 22 ¿ç·þÅÅλ¾º²Â¹«¹²ÐÅÏ¢ #tagGCChampionshipGuessPubInfo

class  tagGCChampionshipGuessPlayerPub(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PlayerID", c_int),    # Ä¿±êÍæ¼ÒID
                  ("SupportCount", c_int),    # Ö§³ÖÈËÊý
                  ]

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

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

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

    def GetLength(self):
        return sizeof(tagGCChampionshipGuessPlayerPub)

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

    def OutputString(self):
        DumpString = '''// C0 22 ¿ç·þÅÅλ¾º²Â¹«¹²ÐÅÏ¢ //tagGCChampionshipGuessPubInfo:
                                PlayerID:%d,
                                SupportCount:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.SupportCount
                                )
        return DumpString


class  tagGCChampionshipGuessPubList(Structure):
    GuessType = 0    #(BYTE GuessType)//¾º²ÂÀàÐÍ 8-8Ç¿£»4-4Ç¿ÅÅλ
    PlayerCount = 0    #(BYTE PlayerCount)
    GuessPlayerList = list()    #(vector<tagGCChampionshipGuessPlayerPub> GuessPlayerList)// ±»¾º²ÂÍæ¼ÒÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GuessType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PlayerCount):
            temGuessPlayerList = tagGCChampionshipGuessPlayerPub()
            _pos = temGuessPlayerList.ReadData(_lpData, _pos)
            self.GuessPlayerList.append(temGuessPlayerList)
        return _pos

    def Clear(self):
        self.GuessType = 0
        self.PlayerCount = 0
        self.GuessPlayerList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.GuessType)
        data = CommFunc.WriteBYTE(data, self.PlayerCount)
        for i in range(self.PlayerCount):
            data = CommFunc.WriteString(data, self.GuessPlayerList[i].GetLength(), self.GuessPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GuessType:%d,
                                PlayerCount:%d,
                                GuessPlayerList:%s
                                '''\
                                %(
                                self.GuessType,
                                self.PlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCChampionshipGuessPubInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ÅÅλÊý¾Ý·ÖÇøID
    Count = 0    #(BYTE Count)
    GuessList = list()    #(vector<tagGCChampionshipGuessPubList> GuessList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temGuessList = tagGCChampionshipGuessPubList()
            _pos = temGuessList.ReadData(_lpData, _pos)
            self.GuessList.append(temGuessList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x22
        self.ZoneID = 0
        self.Count = 0
        self.GuessList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 19 ¿ç·þÅÅλÏɹÙÉêÇë»ØÓ¦½á¹û #tagGCChampionshipOfficialApplyReplyRet

class  tagGCChampionshipOfficialApplyReplyRet(Structure):
    Head = tagHead()
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// ½çÖ÷Íæ¼ÒÃû
    MainOfficialID = 0    #(WORD MainOfficialID)//½çÖ÷¹ÙÖ°ID
    OfficialID = 0    #(WORD OfficialID)//ÉêÇë¹ÙÖ°ID
    IsOK = 0    #(BYTE IsOK)//ÊÇ·ñͬÒ⣻1-ÊÇ£»0-·ñ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x19
        self.NameLen = 0
        self.PlayerName = ""
        self.MainOfficialID = 0
        self.OfficialID = 0
        self.IsOK = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.MainOfficialID)
        data = CommFunc.WriteWORD(data, self.OfficialID)
        data = CommFunc.WriteBYTE(data, self.IsOK)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                NameLen:%d,
                                PlayerName:%s,
                                MainOfficialID:%d,
                                OfficialID:%d,
                                IsOK:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.NameLen,
                                self.PlayerName,
                                self.MainOfficialID,
                                self.OfficialID,
                                self.IsOK
                                )
        return DumpString


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


#------------------------------------------------------
# C0 21 ¿ç·þÅÅλÏɹÙÌôÕ½¼Ç¼ #tagGCChampionshipOfficialChallengeRecordInfo

class  tagGCChampionshipOfficialChallengeRecord(Structure):
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    ChallengeTime = 0    #(DWORD ChallengeTime)//Ìôսʱ¼ä´Á
    Ret = 0    #(BYTE Ret)//ÌôÕ½½á¹û£»0-ʧ°Ü£»1-»ñʤ£»
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.ChallengeTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Ret,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.NameLen = 0
        self.PlayerName = ""
        self.ChallengeTime = 0
        self.Ret = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteDWORD(data, self.ChallengeTime)
        data = CommFunc.WriteBYTE(data, self.Ret)
        return data

    def OutputString(self):
        DumpString = '''
                                NameLen:%d,
                                PlayerName:%s,
                                ChallengeTime:%d,
                                Ret:%d
                                '''\
                                %(
                                self.NameLen,
                                self.PlayerName,
                                self.ChallengeTime,
                                self.Ret
                                )
        return DumpString


class  tagGCChampionshipOfficialChallengeRecordInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ·ÖÇøID
    MainOfficialID = 0    #(WORD MainOfficialID)// ½çÖ÷¹ÙÖ°ID
    OfficialID = 0    #(WORD OfficialID)// ¼Ç¼µÄ¹ÙÖ°ID
    RecordCount = 0    #(BYTE RecordCount)// ÌôÕ½¼Ç¼Êý
    RecordList = list()    #(vector<tagGCChampionshipOfficialChallengeRecord> RecordList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RecordCount):
            temRecordList = tagGCChampionshipOfficialChallengeRecord()
            _pos = temRecordList.ReadData(_lpData, _pos)
            self.RecordList.append(temRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x21
        self.ZoneID = 0
        self.MainOfficialID = 0
        self.OfficialID = 0
        self.RecordCount = 0
        self.RecordList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZoneID:%d,
                                MainOfficialID:%d,
                                OfficialID:%d,
                                RecordCount:%d,
                                RecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZoneID,
                                self.MainOfficialID,
                                self.OfficialID,
                                self.RecordCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 20 ¿ç·þÅÅλÏɹÙÌôÕ½½á¹û #tagGCChampionshipOfficialChallengeRet

class  tagGCChampionshipOfficialChallengeRet(Structure):
    Head = tagHead()
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// Ô­ÏɹÙÍæ¼ÒÃû£¬¿ÉÄÜΪ¿Õ£¬´ú±í±¾À´ÎÞÍæ¼Ò
    MainOfficialID = 0    #(WORD MainOfficialID)//½çÖ÷¹ÙÖ°ID
    OfficialID = 0    #(WORD OfficialID)//ÌôÕ½µÄ¹ÙÖ°ID
    Ret = 0    #(BYTE Ret)//ÌôÕ½½á¹û£»0-ʧ°Ü£»1-»ñʤ£»2-Ä¿±êÏɹÙÍæ¼ÒIDÒѱä¸ü£¬¿ÉˢкóÖØÊÔ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Ret,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x20
        self.NameLen = 0
        self.PlayerName = ""
        self.MainOfficialID = 0
        self.OfficialID = 0
        self.Ret = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.MainOfficialID)
        data = CommFunc.WriteWORD(data, self.OfficialID)
        data = CommFunc.WriteBYTE(data, self.Ret)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                NameLen:%d,
                                PlayerName:%s,
                                MainOfficialID:%d,
                                OfficialID:%d,
                                Ret:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.NameLen,
                                self.PlayerName,
                                self.MainOfficialID,
                                self.OfficialID,
                                self.Ret
                                )
        return DumpString


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


#------------------------------------------------------
# C0 18 ¿ç·þÅÅλ¹ÙÖ°ÐÅÏ¢ #tagGCChampionshipOfficialInfo

class  tagGCChampionshipOfficialPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)// Íæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)
    FightPower = 0    #(DWORD FightPower)// Õ½Á¦ÇóÓàÒÚ²¿·Ö
    FightPowerEx = 0    #(DWORD FightPowerEx)// Õ½Á¦Õû³ýÒÚ²¿·Ö
    RealmLV = 0    #(WORD RealmLV)
    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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCChampionshipOfficial(Structure):
    OfficialID = 0    #(DWORD OfficialID)// ¹ÙÖ°ID
    LastDismissJuniorTime = 0    #(DWORD LastDismissJuniorTime)// ÉϴδÇÍËϼ¶ÏɹÙʱ¼ä´Á£¬¿ç·þʱ¼ä£¬Èç¹û×Ô¼ºÊDZ¾½çÖ÷ʱ£¬ÓÃÓÚ¼ÆËã´ÇÍËCD
    WorshipCount = 0    #(DWORD WorshipCount)// ±»Ä¤°Ý´ÎÊý
    WorshipDouble = 0    #(BYTE WorshipDouble)// ½ñÈÕÊÇ·ñË«±¶Ä¤°Ý£¬½öÔڹ涨ʱ¼äµãÄÚÓÐÓÃ
    OfficialPlayer=tagGCChampionshipOfficialPlayer()    #(tagGCChampionshipOfficialPlayer OfficialPlayer)// ÈÎÖ°Íæ¼ÒÐÅÏ¢£¬¿ÉÄÜûÓÐ
    ApplyPlayerCount = 0    #(BYTE ApplyPlayerCount)// ÉêÇë¸ÃÏɹÙÍæ¼ÒÊý
    ApplyPlayerList = list()    #(vector<tagGCChampionshipOfficialPlayer> ApplyPlayerList)// ÉêÇë¸ÃÏɹÙÍæ¼ÒÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.OfficialID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LastDismissJuniorTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WorshipCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WorshipDouble,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        _pos = self.OfficialPlayer.ReadData(_lpData,_pos)
        self.ApplyPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ApplyPlayerCount):
            temApplyPlayerList = tagGCChampionshipOfficialPlayer()
            _pos = temApplyPlayerList.ReadData(_lpData, _pos)
            self.ApplyPlayerList.append(temApplyPlayerList)
        return _pos

    def Clear(self):
        self.OfficialID = 0
        self.LastDismissJuniorTime = 0
        self.WorshipCount = 0
        self.WorshipDouble = 0
        self.OfficialPlayer=tagGCChampionshipOfficialPlayer()
        self.OfficialPlayer.Clear()
        self.ApplyPlayerCount = 0
        self.ApplyPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 4
        length += 1
        length += self.OfficialPlayer.GetLength()
        length += 1
        for i in range(self.ApplyPlayerCount):
            length += self.ApplyPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.OfficialID)
        data = CommFunc.WriteDWORD(data, self.LastDismissJuniorTime)
        data = CommFunc.WriteDWORD(data, self.WorshipCount)
        data = CommFunc.WriteBYTE(data, self.WorshipDouble)
        data = CommFunc.WriteString(data,self.OfficialPlayer.GetLength(),self.OfficialPlayer.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ApplyPlayerCount)
        for i in range(self.ApplyPlayerCount):
            data = CommFunc.WriteString(data, self.ApplyPlayerList[i].GetLength(), self.ApplyPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                OfficialID:%d,
                                LastDismissJuniorTime:%d,
                                WorshipCount:%d,
                                WorshipDouble:%d,
                                OfficialPlayer:%s,
                                ApplyPlayerCount:%d,
                                ApplyPlayerList:%s
                                '''\
                                %(
                                self.OfficialID,
                                self.LastDismissJuniorTime,
                                self.WorshipCount,
                                self.WorshipDouble,
                                self.OfficialPlayer.OutputString(),
                                self.ApplyPlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCChampionshipOfficialInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ¹ÙÖ°Êý¾Ý·ÖÇøID
    OfficialCount = 0    #(BYTE OfficialCount)// ¹ÙÖ°Êý£¬°üº¬½çÖ÷¼°ËùÓÐÏɹÙ
    OfficialList = list()    #(vector<tagGCChampionshipOfficial> OfficialList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OfficialCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.OfficialCount):
            temOfficialList = tagGCChampionshipOfficial()
            _pos = temOfficialList.ReadData(_lpData, _pos)
            self.OfficialList.append(temOfficialList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x18
        self.ZoneID = 0
        self.OfficialCount = 0
        self.OfficialList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZoneID:%d,
                                OfficialCount:%d,
                                OfficialList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZoneID,
                                self.OfficialCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 09 ¿ç·þÕ½³¡Íæ¼Ò¹ºÂòÕ½³¡ÐÅÏ¢ #tagGCCrossBattlefieldBuyInfo

class  tagGCCrossBattlefieldPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)//µÈ¼¶
    RealmLV = 0    #(WORD RealmLV)//¾³½ç
    FightPower = 0    #(DWORD FightPower)//Õ½Á¦ÇóÓàÒÚ²¿·Ö
    FightPowerEx = 0    #(DWORD FightPowerEx)//Õ½Á¦Õû³ýÒÚ²¿·Ö
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.RealmLV = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        return data

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


class  tagGCCrossBattlefieldBuyPlayer(Structure):
    BuyPlayerID = 0    #(DWORD BuyPlayerID)//¹ºÂòµÄÍæ¼ÒID£¬¼´ÕÙ¼¯ÈË
    Faction = 0    #(BYTE Faction)//ÕóÓª 1-ºì£»2-À¶
    ServerOnly = 0    #(BYTE ServerOnly)//ÊÇ·ñ½ö±¾·þÍæ¼Ò¿É¼ÓÈ룬0-·ñ£¬1-ÊÇ
    FactionPlayerCount = 0    #(BYTE FactionPlayerCount)
    FactionPlayerList = list()    #(vector<tagGCCrossBattlefieldPlayer> FactionPlayerList)//ÕóÓªËùÓÐÍæ¼ÒÁÐ±í£¬°üº¬ÕÙ¼¯ÈË
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.BuyPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Faction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FactionPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FactionPlayerCount):
            temFactionPlayerList = tagGCCrossBattlefieldPlayer()
            _pos = temFactionPlayerList.ReadData(_lpData, _pos)
            self.FactionPlayerList.append(temFactionPlayerList)
        return _pos

    def Clear(self):
        self.BuyPlayerID = 0
        self.Faction = 0
        self.ServerOnly = 0
        self.FactionPlayerCount = 0
        self.FactionPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += 1
        length += 1
        for i in range(self.FactionPlayerCount):
            length += self.FactionPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.BuyPlayerID)
        data = CommFunc.WriteBYTE(data, self.Faction)
        data = CommFunc.WriteBYTE(data, self.ServerOnly)
        data = CommFunc.WriteBYTE(data, self.FactionPlayerCount)
        for i in range(self.FactionPlayerCount):
            data = CommFunc.WriteString(data, self.FactionPlayerList[i].GetLength(), self.FactionPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                BuyPlayerID:%d,
                                Faction:%d,
                                ServerOnly:%d,
                                FactionPlayerCount:%d,
                                FactionPlayerList:%s
                                '''\
                                %(
                                self.BuyPlayerID,
                                self.Faction,
                                self.ServerOnly,
                                self.FactionPlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCCrossBattlefieldBuyHM(Structure):
    Hour = 0    #(BYTE Hour)//Õ½³¡¿ªÆôʱ
    Minute = 0    #(BYTE Minute)//Õ½³¡¿ªÆô·Ö
    BuyPlayerCount = 0    #(BYTE BuyPlayerCount)
    BuyPlayerList = list()    #(vector<tagGCCrossBattlefieldBuyPlayer> BuyPlayerList)//¹ºÂò±¾³¡´ÎµÄÍæ¼ÒÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Hour,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Minute,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.BuyPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BuyPlayerCount):
            temBuyPlayerList = tagGCCrossBattlefieldBuyPlayer()
            _pos = temBuyPlayerList.ReadData(_lpData, _pos)
            self.BuyPlayerList.append(temBuyPlayerList)
        return _pos

    def Clear(self):
        self.Hour = 0
        self.Minute = 0
        self.BuyPlayerCount = 0
        self.BuyPlayerList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Hour)
        data = CommFunc.WriteBYTE(data, self.Minute)
        data = CommFunc.WriteBYTE(data, self.BuyPlayerCount)
        for i in range(self.BuyPlayerCount):
            data = CommFunc.WriteString(data, self.BuyPlayerList[i].GetLength(), self.BuyPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Hour:%d,
                                Minute:%d,
                                BuyPlayerCount:%d,
                                BuyPlayerList:%s
                                '''\
                                %(
                                self.Hour,
                                self.Minute,
                                self.BuyPlayerCount,
                                "..."
                                )
        return DumpString


class  tagGCCrossBattlefieldBuyInfo(Structure):
    Head = tagHead()
    HMCount = 0    #(BYTE HMCount)// Ϊ0ʱÇå¿ÕÖØÖã¬ÆäËûΪÔöÁ¿¸üÐÂ
    HMBuyList = list()    #(vector<tagGCCrossBattlefieldBuyHM> HMBuyList)//¹ºÂò³¡´ÎÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.HMCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.HMCount):
            temHMBuyList = tagGCCrossBattlefieldBuyHM()
            _pos = temHMBuyList.ReadData(_lpData, _pos)
            self.HMBuyList.append(temHMBuyList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x09
        self.HMCount = 0
        self.HMBuyList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 07 ¿ç·þÅÅÐаñÐÅÏ¢ #tagGCCrossBillboardInfo

class  tagGCCrossBillboardData(Structure):
    OrderIndex = 0    #(WORD OrderIndex)//Ãû´ÎË÷Òý£¬0´ú±íµÚÒ»Ãû
    ID = 0    #(DWORD ID)
    ID2 = 0    #(DWORD ID2)
    Name1 = ""    #(char Name1[33])//Ãû×Ö1£¬ÓÃÀ´ÏÔʾÅÅÐò¶ÔÏóÃû×Ö 
    Name2 = ""    #(char Name2[33])//Ãû×Ö2
    Type2 = 0    #(BYTE Type2)//¸½¼ÓÀàÐÍ£¬ÓÃÀ´±íʾÅÅÐò¶ÔÏóµÄÀàÐÍ£¬±ÈÈ磬Íæ¼ÒËùÊôÖ°ÒµÃÅÅÉ£¬³èÎïÀàÐ͵È
    Value1 = 0    #(DWORD Value1)//×Ô¶¨ÒåÖµ1
    Value2 = 0    #(DWORD Value2)//×Ô¶¨ÒåÖµ2
    Value3 = 0    #(DWORD Value3)//¸½¼ÓÖµ
    Value4 = 0    #(DWORD Value4)//¸½¼ÓÖµ
    Value5 = 0    #(DWORD Value5)//¸½¼ÓÖµ
    Value6 = 0    #(DWORD Value6)//¸½¼ÓÖµ
    Value7 = 0    #(DWORD Value7)//¸½¼ÓÖµ
    Value8 = 0    #(DWORD Value8)//¸½¼ÓÖµ
    CmpValue = 0    #(DWORD CmpValue)// ±È½ÏȨֵ
    CmpValue2 = 0    #(DWORD CmpValue2)// ±È½ÏȨֵ
    CmpValue3 = 0    #(DWORD CmpValue3)// ±È½ÏȨֵ
    DataLen = 0    #(WORD DataLen)
    UserData = ""    #(String UserData)//¸½¼Ó
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.OrderIndex,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ID2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Name1,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Name2,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Type2,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Value8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CmpValue3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
        return _pos

    def Clear(self):
        self.OrderIndex = 0
        self.ID = 0
        self.ID2 = 0
        self.Name1 = ""
        self.Name2 = ""
        self.Type2 = 0
        self.Value1 = 0
        self.Value2 = 0
        self.Value3 = 0
        self.Value4 = 0
        self.Value5 = 0
        self.Value6 = 0
        self.Value7 = 0
        self.Value8 = 0
        self.CmpValue = 0
        self.CmpValue2 = 0
        self.CmpValue3 = 0
        self.DataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteWORD(data, self.OrderIndex)
        data = CommFunc.WriteDWORD(data, self.ID)
        data = CommFunc.WriteDWORD(data, self.ID2)
        data = CommFunc.WriteString(data, 33, self.Name1)
        data = CommFunc.WriteString(data, 33, self.Name2)
        data = CommFunc.WriteBYTE(data, self.Type2)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteDWORD(data, self.Value2)
        data = CommFunc.WriteDWORD(data, self.Value3)
        data = CommFunc.WriteDWORD(data, self.Value4)
        data = CommFunc.WriteDWORD(data, self.Value5)
        data = CommFunc.WriteDWORD(data, self.Value6)
        data = CommFunc.WriteDWORD(data, self.Value7)
        data = CommFunc.WriteDWORD(data, self.Value8)
        data = CommFunc.WriteDWORD(data, self.CmpValue)
        data = CommFunc.WriteDWORD(data, self.CmpValue2)
        data = CommFunc.WriteDWORD(data, self.CmpValue3)
        data = CommFunc.WriteWORD(data, self.DataLen)
        data = CommFunc.WriteString(data, self.DataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                OrderIndex:%d,
                                ID:%d,
                                ID2:%d,
                                Name1:%s,
                                Name2:%s,
                                Type2:%d,
                                Value1:%d,
                                Value2:%d,
                                Value3:%d,
                                Value4:%d,
                                Value5:%d,
                                Value6:%d,
                                Value7:%d,
                                Value8:%d,
                                CmpValue:%d,
                                CmpValue2:%d,
                                CmpValue3:%d,
                                DataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.OrderIndex,
                                self.ID,
                                self.ID2,
                                self.Name1,
                                self.Name2,
                                self.Type2,
                                self.Value1,
                                self.Value2,
                                self.Value3,
                                self.Value4,
                                self.Value5,
                                self.Value6,
                                self.Value7,
                                self.Value8,
                                self.CmpValue,
                                self.CmpValue2,
                                self.CmpValue3,
                                self.DataLen,
                                self.UserData
                                )
        return DumpString


class  tagGCCrossBillboardInfo(Structure):
    Head = tagHead()
    Type = 0    #(BYTE Type)//°ñµ¥ÀàÐÍ
    GroupValue1 = 0    #(BYTE GroupValue1)// ·Ö×éÖµ1
    GroupValue2 = 0    #(BYTE GroupValue2)// ·Ö×éÖµ2£¬Óë·Ö×éÖµ1×éºÏ¹éΪͬ×é°ñµ¥Êý¾Ý
    WatchID = 0    #(DWORD WatchID)//²é¿´Ö¸¶¨IDÃû´ÎÇ°ºó£¬ÈçÍæ¼ÒID¡¢¼Ò×åIDµÈ
    BillboardCount = 0    #(BYTE BillboardCount)
    CrossBillboardDataList = list()    #(vector<tagGCCrossBillboardData> CrossBillboardDataList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GroupValue2,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WatchID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BillboardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BillboardCount):
            temCrossBillboardDataList = tagGCCrossBillboardData()
            _pos = temCrossBillboardDataList.ReadData(_lpData, _pos)
            self.CrossBillboardDataList.append(temCrossBillboardDataList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x07
        self.Type = 0
        self.GroupValue1 = 0
        self.GroupValue2 = 0
        self.WatchID = 0
        self.BillboardCount = 0
        self.CrossBillboardDataList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.GroupValue1)
        data = CommFunc.WriteBYTE(data, self.GroupValue2)
        data = CommFunc.WriteDWORD(data, self.WatchID)
        data = CommFunc.WriteBYTE(data, self.BillboardCount)
        for i in range(self.BillboardCount):
            data = CommFunc.WriteString(data, self.CrossBillboardDataList[i].GetLength(), self.CrossBillboardDataList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Type:%d,
                                GroupValue1:%d,
                                GroupValue2:%d,
                                WatchID:%d,
                                BillboardCount:%d,
                                CrossBillboardDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Type,
                                self.GroupValue1,
                                self.GroupValue2,
                                self.WatchID,
                                self.BillboardCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 16 ¿ç·þÅÅλս¶·½á¹û #tagGCCrossChampionshipPKOver

class  tagGCCrossChampionshipPKOver(Structure):
    Head = tagHead()
    GroupMark = 0    #(DWORD GroupMark)// ·Ö×é±êʶ£º64¡¢32¡¢16¡¢8 - 64¡¢32¡¢16¡¢8Ç¿Èü£»4 - °ë¾öÈü£» 2 - ¾öÈü
    TimeStr = ""    #(char TimeStr[19])// ½áËãʱ¼ä£¬¸ñʽ yyyy-MM-dd HH:mm:ss
    OverType = 0    #(BYTE OverType)// 0-Õý³££¬1-ÓÐÈËÀëÏß
    WinnerID = 0    #(DWORD WinnerID)// ʤ·½ID
    LoserID = 0    #(DWORD LoserID)// °Ü·½ID
    RoundCount = 0    #(BYTE RoundCount)// PK»ØºÏÊý
    RoundWinnerID = list()    #(vector<DWORD> RoundWinnerID)// »ØºÏ»ñʤIDÁбí
    TagNameLen = 0    #(BYTE TagNameLen)
    TagName = ""    #(String TagName)
    Rank = 0    #(BYTE Rank)// ×îÖÕÃû´Î£¬¾öÈü²ÅÓÐ
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.GroupMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.OverType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WinnerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LoserID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RoundCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RoundCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.RoundWinnerID.append(value)
        self.TagNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TagName,_pos = CommFunc.ReadString(_lpData, _pos,self.TagNameLen)
        self.Rank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x16
        self.GroupMark = 0
        self.TimeStr = ""
        self.OverType = 0
        self.WinnerID = 0
        self.LoserID = 0
        self.RoundCount = 0
        self.RoundWinnerID = list()
        self.TagNameLen = 0
        self.TagName = ""
        self.Rank = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 19
        length += 1
        length += 4
        length += 4
        length += 1
        length += 4 * self.RoundCount
        length += 1
        length += len(self.TagName)
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.GroupMark)
        data = CommFunc.WriteString(data, 19, self.TimeStr)
        data = CommFunc.WriteBYTE(data, self.OverType)
        data = CommFunc.WriteDWORD(data, self.WinnerID)
        data = CommFunc.WriteDWORD(data, self.LoserID)
        data = CommFunc.WriteBYTE(data, self.RoundCount)
        for i in range(self.RoundCount):
            data = CommFunc.WriteDWORD(data, self.RoundWinnerID[i])
        data = CommFunc.WriteBYTE(data, self.TagNameLen)
        data = CommFunc.WriteString(data, self.TagNameLen, self.TagName)
        data = CommFunc.WriteBYTE(data, self.Rank)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                GroupMark:%d,
                                TimeStr:%s,
                                OverType:%d,
                                WinnerID:%d,
                                LoserID:%d,
                                RoundCount:%d,
                                RoundWinnerID:%s,
                                TagNameLen:%d,
                                TagName:%s,
                                Rank:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.GroupMark,
                                self.TimeStr,
                                self.OverType,
                                self.WinnerID,
                                self.LoserID,
                                self.RoundCount,
                                "...",
                                self.TagNameLen,
                                self.TagName,
                                self.Rank
                                )
        return DumpString


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


#------------------------------------------------------
# C0 15 ¿ç·þÅÅλ·ÖÇø·Ö×éÐÅÏ¢ #tagGCCrossChampionshipPKZoneGroupInfo

class  tagGCCrossChampionshipPKBattle(Structure):
    _pack_ = 1
    _fields_ = [
                  ("BattleNum", c_ubyte),    # ¶ÔÕ½×é±àºÅ 1~n
                  ("WinPlayerID", c_int),    # »ñʤÍæ¼ÒID
                  ("PlayerIDA", c_int),    # Íæ¼ÒIDA
                  ("PlayerIDB", c_int),    # Íæ¼ÒIDB
                  ]

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

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

    def Clear(self):
        self.BattleNum = 0
        self.WinPlayerID = 0
        self.PlayerIDA = 0
        self.PlayerIDB = 0
        return

    def GetLength(self):
        return sizeof(tagGCCrossChampionshipPKBattle)

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

    def OutputString(self):
        DumpString = '''// C0 15 ¿ç·þÅÅλ·ÖÇø·Ö×éÐÅÏ¢ //tagGCCrossChampionshipPKZoneGroupInfo:
                                BattleNum:%d,
                                WinPlayerID:%d,
                                PlayerIDA:%d,
                                PlayerIDB:%d
                                '''\
                                %(
                                self.BattleNum,
                                self.WinPlayerID,
                                self.PlayerIDA,
                                self.PlayerIDB
                                )
        return DumpString


class  tagGCCrossChampionshipPKGroup(Structure):
    GroupMark = 0    #(DWORD GroupMark)// Õ½¶··ÖÇømark, Èç 64¡¢32¡¢16¡¢8¡¢4-°ë¾öÈü¡¢2-¾öÈü£»
    BattleCount = 0    #(BYTE BattleCount)// ¶ÔÕ½×éÊý
    BattleList = list()    #(vector<tagGCCrossChampionshipPKBattle> BattleList)// ¶ÔÕ½×éÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GroupMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BattleCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BattleCount):
            temBattleList = tagGCCrossChampionshipPKBattle()
            _pos = temBattleList.ReadData(_lpData, _pos)
            self.BattleList.append(temBattleList)
        return _pos

    def Clear(self):
        self.GroupMark = 0
        self.BattleCount = 0
        self.BattleList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.BattleCount):
            length += self.BattleList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.GroupMark)
        data = CommFunc.WriteBYTE(data, self.BattleCount)
        for i in range(self.BattleCount):
            data = CommFunc.WriteString(data, self.BattleList[i].GetLength(), self.BattleList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GroupMark:%d,
                                BattleCount:%d,
                                BattleList:%s
                                '''\
                                %(
                                self.GroupMark,
                                self.BattleCount,
                                "..."
                                )
        return DumpString


class  tagGCCrossChampionshipPKPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)// Íæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)
    FightPower = 0    #(DWORD FightPower)// Õ½Á¦ÇóÓàÒÚ²¿·Ö
    FightPowerEx = 0    #(DWORD FightPowerEx)// Õ½Á¦Õû³ýÒÚ²¿·Ö
    RealmLV = 0    #(WORD RealmLV)
    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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.FightPower = 0
        self.FightPowerEx = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPowerEx)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        return data

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


class  tagGCCrossChampionshipPKZoneGroupInfo(Structure):
    Head = tagHead()
    ActID = 0    #(DWORD ActID)// »î¶¯ID£¬»î¶¯ID²»Í¬Ôò¿ÉÖØÖÃÇ°¶ËÅÅλÈüÏà¹Ø»º´æÊý¾Ý
    StateError = 0    #(BYTE StateError)// ±¾´Î»î¶¯ÊÇ·ñÒѾ­³öÏÖÁ÷³Ì״̬Òì³££»Èç·þÎñÆ÷Òì³£»òά»¤·þÎñÆ÷µ¼ÖÂÌø¹ý²½Ö裬Ôò»á·ÏÆú¸Ã´Î±ÈÈü£¬Ö±µ½Ï´Îл£»
    ZoneID = 0    #(BYTE ZoneID)// ÅÅλ·ÖÇøID
    PlayerCount = 0    #(BYTE PlayerCount)// ²ÎÈüÍæ¼ÒÊý
    PlayerList = list()    #(vector<tagGCCrossChampionshipPKPlayer> PlayerList)
    GroupCount = 0    #(WORD GroupCount)
    GroupList = list()    #(vector<tagGCCrossChampionshipPKGroup> GroupList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.StateError,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PlayerCount):
            temPlayerList = tagGCCrossChampionshipPKPlayer()
            _pos = temPlayerList.ReadData(_lpData, _pos)
            self.PlayerList.append(temPlayerList)
        self.GroupCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.GroupCount):
            temGroupList = tagGCCrossChampionshipPKGroup()
            _pos = temGroupList.ReadData(_lpData, _pos)
            self.GroupList.append(temGroupList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x15
        self.ActID = 0
        self.StateError = 0
        self.ZoneID = 0
        self.PlayerCount = 0
        self.PlayerList = list()
        self.GroupCount = 0
        self.GroupList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        length += 1
        for i in range(self.PlayerCount):
            length += self.PlayerList[i].GetLength()
        length += 2
        for i in range(self.GroupCount):
            length += self.GroupList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ActID)
        data = CommFunc.WriteBYTE(data, self.StateError)
        data = CommFunc.WriteBYTE(data, self.ZoneID)
        data = CommFunc.WriteBYTE(data, self.PlayerCount)
        for i in range(self.PlayerCount):
            data = CommFunc.WriteString(data, self.PlayerList[i].GetLength(), self.PlayerList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.GroupCount)
        for i in range(self.GroupCount):
            data = CommFunc.WriteString(data, self.GroupList[i].GetLength(), self.GroupList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActID:%d,
                                StateError:%d,
                                ZoneID:%d,
                                PlayerCount:%d,
                                PlayerList:%s,
                                GroupCount:%d,
                                GroupList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActID,
                                self.StateError,
                                self.ZoneID,
                                self.PlayerCount,
                                "...",
                                self.GroupCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 05 ¿ç·þPKÈü¼¾ÅÅÐаñ #tagGCCrossRealmPKBillboardInfo

class  tagGCCrossRealmPKBillboardData(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    Job = 0    #(BYTE Job)
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    FightPower = 0    #(DWORD FightPower)
    RealmLV = 0    #(WORD RealmLV)
    PKScore = 0    #(DWORD PKScore)
    DanLV = 0    #(BYTE DanLV)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PKScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DanLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.Job = 0
        self.Face = 0
        self.FacePic = 0
        self.FightPower = 0
        self.RealmLV = 0
        self.PKScore = 0
        self.DanLV = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.PKScore)
        data = CommFunc.WriteBYTE(data, self.DanLV)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                Job:%d,
                                Face:%d,
                                FacePic:%d,
                                FightPower:%d,
                                RealmLV:%d,
                                PKScore:%d,
                                DanLV:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.Job,
                                self.Face,
                                self.FacePic,
                                self.FightPower,
                                self.RealmLV,
                                self.PKScore,
                                self.DanLV
                                )
        return DumpString


class  tagGCCrossRealmPKBillboardInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ÈüÇøID	
    SeasonID = 0    #(BYTE SeasonID)// Èü¼¾ID	
    Count = 0    #(WORD Count)
    PKBillboardList = list()    #(vector<tagGCCrossRealmPKBillboardData> PKBillboardList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SeasonID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temPKBillboardList = tagGCCrossRealmPKBillboardData()
            _pos = temPKBillboardList.ReadData(_lpData, _pos)
            self.PKBillboardList.append(temPKBillboardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x05
        self.ZoneID = 0
        self.SeasonID = 0
        self.Count = 0
        self.PKBillboardList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 01 ¿ç·þPKÆ¥Åä³É¹¦ #tagGCCrossRealmPKMatchOK

class  tagGCCrossRealmPKMatchPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// ¿ç·þÃû×Ö
    Job = 0    #(BYTE Job)
    LV = 0    #(WORD LV)
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    MaxHP = 0    #(DWORD MaxHP)// ĬÈÏÂúѪ£¬ÇóÓàÒÚ²¿·Ö
    MaxHPEx = 0    #(DWORD MaxHPEx)// ĬÈÏÂúѪ£¬Õû³ýÒÚ²¿·Ö
    MaxProDef = 0    #(DWORD MaxProDef)// ×î´ó»¤¶Ü
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxProDef,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.Job = 0
        self.LV = 0
        self.Face = 0
        self.FacePic = 0
        self.MaxHP = 0
        self.MaxHPEx = 0
        self.MaxProDef = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.MaxHP)
        data = CommFunc.WriteDWORD(data, self.MaxHPEx)
        data = CommFunc.WriteDWORD(data, self.MaxProDef)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                Job:%d,
                                LV:%d,
                                Face:%d,
                                FacePic:%d,
                                MaxHP:%d,
                                MaxHPEx:%d,
                                MaxProDef:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.Job,
                                self.LV,
                                self.Face,
                                self.FacePic,
                                self.MaxHP,
                                self.MaxHPEx,
                                self.MaxProDef
                                )
        return DumpString


class  tagGCCrossRealmPKMatchOK(Structure):
    Head = tagHead()
    RoomID = 0    #(WORD RoomID)// ·¿¼äID
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// ¿ç·þÃû×Ö
    Number = 0    #(BYTE Number)// λÖñàºÅ£»1-×ó£¬2-ÓÒ
    MatchPlayerCount = 0    #(BYTE MatchPlayerCount)
    MatchPlayer = list()    #(vector<tagGCCrossRealmPKMatchPlayer> MatchPlayer)// Æ¥Åäµ½µÄÍæ¼Ò
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RoomID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.Number,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MatchPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MatchPlayerCount):
            temMatchPlayer = tagGCCrossRealmPKMatchPlayer()
            _pos = temMatchPlayer.ReadData(_lpData, _pos)
            self.MatchPlayer.append(temMatchPlayer)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x01
        self.RoomID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.Number = 0
        self.MatchPlayerCount = 0
        self.MatchPlayer = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 1
        length += len(self.PlayerName)
        length += 1
        length += 1
        for i in range(self.MatchPlayerCount):
            length += self.MatchPlayer[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RoomID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Number)
        data = CommFunc.WriteBYTE(data, self.MatchPlayerCount)
        for i in range(self.MatchPlayerCount):
            data = CommFunc.WriteString(data, self.MatchPlayer[i].GetLength(), self.MatchPlayer[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RoomID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                Number:%d,
                                MatchPlayerCount:%d,
                                MatchPlayer:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RoomID,
                                self.NameLen,
                                self.PlayerName,
                                self.Number,
                                self.MatchPlayerCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 03 ¿ç·þPKÕ½¶·½á¹û #tagGCCrossRealmPKOverInfo

class  tagGCCrossRealmPKOverInfo(Structure):
    Head = tagHead()
    TimeStr = ""    #(char TimeStr[19])// ½áËãʱ¼ä£¬¸ñʽ yyyy-MM-dd HH:mm:ss
    OverType = 0    #(BYTE OverType)// 0-Õý³££¬1-ÓÐÈËÀëÏß
    WinnerID = 0    #(DWORD WinnerID)// ʤ·½ID
    RoundCount = 0    #(BYTE RoundCount)// PK»ØºÏÊý
    RoundWinnerID = list()    #(vector<DWORD> RoundWinnerID)// »ØºÏ»ñʤIDÁбí
    AddScore = 0    #(WORD AddScore)// ±¾³¡¼Ó·Ö
    Score = 0    #(DWORD Score)// µ±Ç°»ý·Ö
    DanLV = 0    #(BYTE DanLV)// µ±Ç°¶Îλ
    CWinCnt = 0    #(WORD CWinCnt)// µ±Ç°Á¬Ê¤Êý
    TagNameLen = 0    #(BYTE TagNameLen)
    TagName = ""    #(String TagName)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,19)
        self.OverType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WinnerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RoundCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RoundCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.RoundWinnerID.append(value)
        self.AddScore,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DanLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CWinCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TagNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TagName,_pos = CommFunc.ReadString(_lpData, _pos,self.TagNameLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x03
        self.TimeStr = ""
        self.OverType = 0
        self.WinnerID = 0
        self.RoundCount = 0
        self.RoundWinnerID = list()
        self.AddScore = 0
        self.Score = 0
        self.DanLV = 0
        self.CWinCnt = 0
        self.TagNameLen = 0
        self.TagName = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 19
        length += 1
        length += 4
        length += 1
        length += 4 * self.RoundCount
        length += 2
        length += 4
        length += 1
        length += 2
        length += 1
        length += len(self.TagName)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 19, self.TimeStr)
        data = CommFunc.WriteBYTE(data, self.OverType)
        data = CommFunc.WriteDWORD(data, self.WinnerID)
        data = CommFunc.WriteBYTE(data, self.RoundCount)
        for i in range(self.RoundCount):
            data = CommFunc.WriteDWORD(data, self.RoundWinnerID[i])
        data = CommFunc.WriteWORD(data, self.AddScore)
        data = CommFunc.WriteDWORD(data, self.Score)
        data = CommFunc.WriteBYTE(data, self.DanLV)
        data = CommFunc.WriteWORD(data, self.CWinCnt)
        data = CommFunc.WriteBYTE(data, self.TagNameLen)
        data = CommFunc.WriteString(data, self.TagNameLen, self.TagName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TimeStr:%s,
                                OverType:%d,
                                WinnerID:%d,
                                RoundCount:%d,
                                RoundWinnerID:%s,
                                AddScore:%d,
                                Score:%d,
                                DanLV:%d,
                                CWinCnt:%d,
                                TagNameLen:%d,
                                TagName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TimeStr,
                                self.OverType,
                                self.WinnerID,
                                self.RoundCount,
                                "...",
                                self.AddScore,
                                self.Score,
                                self.DanLV,
                                self.CWinCnt,
                                self.TagNameLen,
                                self.TagName
                                )
        return DumpString


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


#------------------------------------------------------
# C0 04 ¿ç·þPKÈüÇøÈü¼¾ÐÅÏ¢ #tagGCCrossRealmPKSeasonInfo

class  tagGCCrossRealmPKSeason(Structure):
    SeasonID = 0    #(WORD SeasonID)// µ±Ç°Èü¼¾ID
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ yyyy-MM-dd
    EndDate = ""    #(char EndDate[10])// ½áÊøÈÕÆÚ yyyy-MM-dd
    EndTime = ""    #(char EndTime[5])// Èü¼¾½áËãʱ¼ä£¬Èü¼¾½±Àø¸Ãʱ¼äºó²Å¿ÉÁìÈ¡ hh:mm
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.SeasonID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.SeasonID = 0
        self.StartDate = ""
        self.EndDate = ""
        self.EndTime = ""
        return

    def GetLength(self):
        length = 0
        length += 2
        length += 10
        length += 10
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteWORD(data, self.SeasonID)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndDate)
        data = CommFunc.WriteString(data, 5, self.EndTime)
        return data

    def OutputString(self):
        DumpString = '''
                                SeasonID:%d,
                                StartDate:%s,
                                EndDate:%s,
                                EndTime:%s
                                '''\
                                %(
                                self.SeasonID,
                                self.StartDate,
                                self.EndDate,
                                self.EndTime
                                )
        return DumpString


class  tagGCCrossRealmPKZone(Structure):
    ZoneID = 0    #(BYTE ZoneID)// ÈüÇøID
    ZoneNameLen = 0    #(BYTE ZoneNameLen)
    ZoneName = ""    #(String ZoneName)// ÈüÇøÃû
    SeasonCount = 0    #(WORD SeasonCount)
    SeasonList = list()    #(vector<tagGCCrossRealmPKSeason> SeasonList)// Èü¼¾Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ZoneNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ZoneName,_pos = CommFunc.ReadString(_lpData, _pos,self.ZoneNameLen)
        self.SeasonCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.SeasonCount):
            temSeasonList = tagGCCrossRealmPKSeason()
            _pos = temSeasonList.ReadData(_lpData, _pos)
            self.SeasonList.append(temSeasonList)
        return _pos

    def Clear(self):
        self.ZoneID = 0
        self.ZoneNameLen = 0
        self.ZoneName = ""
        self.SeasonCount = 0
        self.SeasonList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += len(self.ZoneName)
        length += 2
        for i in range(self.SeasonCount):
            length += self.SeasonList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ZoneID)
        data = CommFunc.WriteBYTE(data, self.ZoneNameLen)
        data = CommFunc.WriteString(data, self.ZoneNameLen, self.ZoneName)
        data = CommFunc.WriteWORD(data, self.SeasonCount)
        for i in range(self.SeasonCount):
            data = CommFunc.WriteString(data, self.SeasonList[i].GetLength(), self.SeasonList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                ZoneID:%d,
                                ZoneNameLen:%d,
                                ZoneName:%s,
                                SeasonCount:%d,
                                SeasonList:%s
                                '''\
                                %(
                                self.ZoneID,
                                self.ZoneNameLen,
                                self.ZoneName,
                                self.SeasonCount,
                                "..."
                                )
        return DumpString


class  tagGCCrossRealmPKSeasonInfo(Structure):
    Head = tagHead()
    ZoneCount = 0    #(BYTE ZoneCount)// ÈüÇø¸öÊý
    ZoneList = list()    #(vector<tagGCCrossRealmPKZone> ZoneList)// ÈüÇøÁбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ZoneCount):
            temZoneList = tagGCCrossRealmPKZone()
            _pos = temZoneList.ReadData(_lpData, _pos)
            self.ZoneList.append(temZoneList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x04
        self.ZoneCount = 0
        self.ZoneList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 06 ¿ç·þPK±¾·þÈü¼¾×´Ì¬ #tagGCCrossRealmPKSeasonState

class  tagGCCrossRealmPKSeasonState(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ËùÊôÈüÇøID
    SeasonID = 0    #(WORD SeasonID)// µ±Ç°Èü¼¾ID
    SeasonState = 0    #(BYTE SeasonState)// Èü¼¾×´Ì¬£»0-먦Æô£¬1-¿ªÆôÖУ¬2-ÒѽáÊø
    MatchState = 0    #(BYTE MatchState)// Æ¥Åä״̬£»0-먦Æô£»1-¿ªÆôÖÐ
    CrossZoneNameLen = 0    #(BYTE CrossZoneNameLen)
    CrossZoneName = ""    #(String CrossZoneName)// ¿ç·þ·ÖÇøÃû
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SeasonID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.SeasonState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MatchState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CrossZoneNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CrossZoneName,_pos = CommFunc.ReadString(_lpData, _pos,self.CrossZoneNameLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x06
        self.ZoneID = 0
        self.SeasonID = 0
        self.SeasonState = 0
        self.MatchState = 0
        self.CrossZoneNameLen = 0
        self.CrossZoneName = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ZoneID)
        data = CommFunc.WriteWORD(data, self.SeasonID)
        data = CommFunc.WriteBYTE(data, self.SeasonState)
        data = CommFunc.WriteBYTE(data, self.MatchState)
        data = CommFunc.WriteBYTE(data, self.CrossZoneNameLen)
        data = CommFunc.WriteString(data, self.CrossZoneNameLen, self.CrossZoneName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZoneID:%d,
                                SeasonID:%d,
                                SeasonState:%d,
                                MatchState:%d,
                                CrossZoneNameLen:%d,
                                CrossZoneName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZoneID,
                                self.SeasonID,
                                self.SeasonState,
                                self.MatchState,
                                self.CrossZoneNameLen,
                                self.CrossZoneName
                                )
        return DumpString


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


#------------------------------------------------------
# C0 02 ¿ç·þPK¿ªÊ¼Æ¥Åä #tagGCCrossRealmPKStartMatch

class  tagGCCrossRealmPKStartMatch(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsRobot", c_ubyte),    # ÊÇ·ñÆ¥Åä»úÆ÷ÈË
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xC0
        self.SubCmd = 0x02
        self.IsRobot = 0
        return

    def GetLength(self):
        return sizeof(tagGCCrossRealmPKStartMatch)

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

    def OutputString(self):
        DumpString = '''// C0 02 ¿ç·þPK¿ªÊ¼Æ¥Åä //tagGCCrossRealmPKStartMatch:
                                Cmd:%s,
                                SubCmd:%s,
                                IsRobot:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsRobot
                                )
        return DumpString


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


#------------------------------------------------------
# C0 11 ¿ç·þÑýħbossÍæ¼ÒÉ˺¦ÐÅÏ¢ #tagGCCrossYaomoBossPlayerHurtInfo

class  tagGCCrossYaomoBossPlayerHurtInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("HurtTotal", c_int),    # ×ÜÉ˺¦Öµ£¬Ð¡ÓÚÒÚ²¿·Ö
                  ("HurtTotalEx", c_int),    # ×ÜÉ˺¦Öµ£¬Õû³ýÒÚ²¿·Ö
                  ("AwardState", c_int),    # É˺¦Ä¿±êÖµÁ콱״̬£¬°´½±Àø¼Ç¼Ë÷ÒýλÔËËãÅжÏÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC0
        self.SubCmd = 0x11
        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 = 0x11
        self.HurtTotal = 0
        self.HurtTotalEx = 0
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagGCCrossYaomoBossPlayerHurtInfo)

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

    def OutputString(self):
        DumpString = '''// C0 11 ¿ç·þÑýħbossÍæ¼ÒÉ˺¦ÐÅÏ¢ //tagGCCrossYaomoBossPlayerHurtInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                HurtTotal:%d,
                                HurtTotalEx:%d,
                                AwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.HurtTotal,
                                self.HurtTotalEx,
                                self.AwardState
                                )
        return DumpString


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


#------------------------------------------------------
# C0 10 ¿ç·þËùÊô·ÖÇøÐÅÏ¢ #tagGCCrossZoneInfo

class  tagGCCrossZoneInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CommZoneID", c_ubyte),    # ËùÊô³£¹æ·ÖÇøID
                  ]

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

    def GetLength(self):
        return sizeof(tagGCCrossZoneInfo)

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

    def OutputString(self):
        DumpString = '''// C0 10 ¿ç·þËùÊô·ÖÇøÐÅÏ¢ //tagGCCrossZoneInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                CommZoneID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CommZoneID
                                )
        return DumpString


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


#------------------------------------------------------
# C0 14 ÐÒÔËÔƹº¿ª½±¼Ç¼ #tagGCLuckyCloudBuyLotteryRecInfo

class  tagGCLuckyCloudBuyLotteryRec(Structure):
    SuperItemID = 0    #(DWORD SuperItemID)// ´ó½±ÎïÆ·ID
    SuperItemCount = 0    #(BYTE SuperItemCount)// ´ó½±ÎïÆ·¸öÊý
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)// Öн±Íæ¼ÒÃû
    LotteryNum = 0    #(WORD LotteryNum)// ¿ª½±ºÅÂë
    LotteryTime = 0    #(DWORD LotteryTime)// ¿ª½±Ê±¼ä´Á£¬Ãë
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.SuperItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LotteryNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LotteryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.SuperItemID = 0
        self.SuperItemCount = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.LotteryNum = 0
        self.LotteryTime = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.SuperItemID)
        data = CommFunc.WriteBYTE(data, self.SuperItemCount)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.LotteryNum)
        data = CommFunc.WriteDWORD(data, self.LotteryTime)
        return data

    def OutputString(self):
        DumpString = '''
                                SuperItemID:%d,
                                SuperItemCount:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                LotteryNum:%d,
                                LotteryTime:%d
                                '''\
                                %(
                                self.SuperItemID,
                                self.SuperItemCount,
                                self.NameLen,
                                self.PlayerName,
                                self.LotteryNum,
                                self.LotteryTime
                                )
        return DumpString


class  tagGCLuckyCloudBuyLotteryRecInfo(Structure):
    Head = tagHead()
    ZoneCount = 0    #(BYTE ZoneCount)// ·ÖÇøÊý
    ZoneIDList = list()    #(vector<BYTE> ZoneIDList)// ËùÓзÖÇøIDÁбí
    ZoneID = 0    #(BYTE ZoneID)// ·µ»Ø¼Ç¼·ÖÇøID
    Count = 0    #(WORD Count)
    LotteryRecList = list()    #(vector<tagGCLuckyCloudBuyLotteryRec> LotteryRecList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ZoneCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.ZoneIDList.append(value)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temLotteryRecList = tagGCLuckyCloudBuyLotteryRec()
            _pos = temLotteryRecList.ReadData(_lpData, _pos)
            self.LotteryRecList.append(temLotteryRecList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x14
        self.ZoneCount = 0
        self.ZoneIDList = list()
        self.ZoneID = 0
        self.Count = 0
        self.LotteryRecList = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZoneCount:%d,
                                ZoneIDList:%s,
                                ZoneID:%d,
                                Count:%d,
                                LotteryRecList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZoneCount,
                                "...",
                                self.ZoneID,
                                self.Count,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# C0 13 ÐÒÔËÔƹº¹ºÂòºÅÂë¼Ç¼ #tagGCLuckyCloudBuyNumRecInfo

class  tagGCLuckyCloudBuyNumRec(Structure):
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    BuyNum = 0    #(WORD BuyNum)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.BuyNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.NameLen = 0
        self.PlayerName = ""
        self.BuyNum = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        length += len(self.PlayerName)
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.BuyNum)
        return data

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


class  tagGCLuckyCloudBuyNumRecInfo(Structure):
    Head = tagHead()
    RemainCount = 0    #(WORD RemainCount)// ¿ª½±Ê£Óà·ÝÊý
    Count = 0    #(WORD Count)
    BuyNumRecList = list()    #(vector<tagGCLuckyCloudBuyNumRec> BuyNumRecList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RemainCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temBuyNumRecList = tagGCLuckyCloudBuyNumRec()
            _pos = temBuyNumRecList.ReadData(_lpData, _pos)
            self.BuyNumRecList.append(temBuyNumRecList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x13
        self.RemainCount = 0
        self.Count = 0
        self.BuyNumRecList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# C0 12 ÐÒÔËÔƹºÂÖ´ÎÐÅÏ¢ #tagGCLuckyCloudBuyRoundInfo

class  tagGCLuckyCloudBuyRoundItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    # ÊÇ·ñÅÄÆ·
                  ]

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

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

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagGCLuckyCloudBuyRoundItem)

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

    def OutputString(self):
        DumpString = '''// C0 12 ÐÒÔËÔƹºÂÖ´ÎÐÅÏ¢ //tagGCLuckyCloudBuyRoundInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagGCLuckyCloudBuyRoundTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    RoundMax = 0    #(BYTE RoundMax)// ±¾Ê±¶Î×î´óÂÖ´Î
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.RoundMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        self.RoundMax = 0
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        data = CommFunc.WriteBYTE(data, self.RoundMax)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s,
                                RoundMax:%d
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime,
                                self.RoundMax
                                )
        return DumpString


class  tagGCLuckyCloudBuyRoundInfo(Structure):
    Head = tagHead()
    ZoneID = 0    #(BYTE ZoneID)// ËùÊô·ÖÇøID
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    RoundTimeCount = 0    #(BYTE RoundTimeCount)
    RoundTimeList = list()    #(vector<tagGCLuckyCloudBuyRoundTime> RoundTimeList)//ÂÖ´Îʱ¼ä¶Î
    RoundID = 0    #(DWORD RoundID)// ÂÖ´ÎΨһID±êʶ£¬µ±ÊÕµ½µÄÂÖ´ÎID±ä¸üʱ£¬Ç°¶ËÐèÇå¿Õ¹ºÂòºÅÂë¼Ç¼»º´æ
    RoundNum = 0    #(BYTE RoundNum)// µ±Ç°Ê±¶ÎµÚ¼¸ÂÖ
    SuperItemID = 0    #(DWORD SuperItemID)// ´ó½±ÎïÆ·ID
    SuperItemCount = 0    #(BYTE SuperItemCount)// ´ó½±ÎïÆ·¸öÊý
    SuperItemMoneyType = 0    #(BYTE SuperItemMoneyType)// ´ó½±¼ÛÖµ»õ±ÒÀàÐÍ
    SuperItemMoneyValue = 0    #(DWORD SuperItemMoneyValue)// ´ó½±¼ÛÖµ
    LVLimit = 0    #(WORD LVLimit)//¿ªÆôµÈ¼¶
    BaseItemCount = 0    #(BYTE BaseItemCount)// ÿ´Î¹ºÂò¹Ì¶¨½±ÀøÎïÆ·Êý
    BaseItemList = list()    #(vector<tagGCLuckyCloudBuyRoundItem> BaseItemList)// ÿ´Î¹ºÂò¹Ì¶¨½±ÀøÎïÆ·ÐÅÏ¢
    RandItemCount = 0    #(BYTE RandItemCount)// ÿ´Î¹ºÂòËæ»ú½±ÀøÎïÆ·Êý
    RandItemList = list()    #(vector<tagGCLuckyCloudBuyRoundItem> RandItemList)// ÿ´Î¹ºÂòËæ»ú½±ÀøÎïÆ·ÐÅÏ¢
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.RoundTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RoundTimeCount):
            temRoundTimeList = tagGCLuckyCloudBuyRoundTime()
            _pos = temRoundTimeList.ReadData(_lpData, _pos)
            self.RoundTimeList.append(temRoundTimeList)
        self.RoundID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RoundNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SuperItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SuperItemMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SuperItemMoneyValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LVLimit,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BaseItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BaseItemCount):
            temBaseItemList = tagGCLuckyCloudBuyRoundItem()
            _pos = temBaseItemList.ReadData(_lpData, _pos)
            self.BaseItemList.append(temBaseItemList)
        self.RandItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RandItemCount):
            temRandItemList = tagGCLuckyCloudBuyRoundItem()
            _pos = temRandItemList.ReadData(_lpData, _pos)
            self.RandItemList.append(temRandItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC0
        self.Head.SubCmd = 0x12
        self.ZoneID = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.RoundTimeCount = 0
        self.RoundTimeList = list()
        self.RoundID = 0
        self.RoundNum = 0
        self.SuperItemID = 0
        self.SuperItemCount = 0
        self.SuperItemMoneyType = 0
        self.SuperItemMoneyValue = 0
        self.LVLimit = 0
        self.BaseItemCount = 0
        self.BaseItemList = list()
        self.RandItemCount = 0
        self.RandItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        for i in range(self.RoundTimeCount):
            length += self.RoundTimeList[i].GetLength()
        length += 4
        length += 1
        length += 4
        length += 1
        length += 1
        length += 4
        length += 2
        length += 1
        for i in range(self.BaseItemCount):
            length += self.BaseItemList[i].GetLength()
        length += 1
        for i in range(self.RandItemCount):
            length += self.RandItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ZoneID)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.RoundTimeCount)
        for i in range(self.RoundTimeCount):
            data = CommFunc.WriteString(data, self.RoundTimeList[i].GetLength(), self.RoundTimeList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.RoundID)
        data = CommFunc.WriteBYTE(data, self.RoundNum)
        data = CommFunc.WriteDWORD(data, self.SuperItemID)
        data = CommFunc.WriteBYTE(data, self.SuperItemCount)
        data = CommFunc.WriteBYTE(data, self.SuperItemMoneyType)
        data = CommFunc.WriteDWORD(data, self.SuperItemMoneyValue)
        data = CommFunc.WriteWORD(data, self.LVLimit)
        data = CommFunc.WriteBYTE(data, self.BaseItemCount)
        for i in range(self.BaseItemCount):
            data = CommFunc.WriteString(data, self.BaseItemList[i].GetLength(), self.BaseItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.RandItemCount)
        for i in range(self.RandItemCount):
            data = CommFunc.WriteString(data, self.RandItemList[i].GetLength(), self.RandItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZoneID:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                RoundTimeCount:%d,
                                RoundTimeList:%s,
                                RoundID:%d,
                                RoundNum:%d,
                                SuperItemID:%d,
                                SuperItemCount:%d,
                                SuperItemMoneyType:%d,
                                SuperItemMoneyValue:%d,
                                LVLimit:%d,
                                BaseItemCount:%d,
                                BaseItemList:%s,
                                RandItemCount:%d,
                                RandItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZoneID,
                                self.StartDate,
                                self.EndtDate,
                                self.RoundTimeCount,
                                "...",
                                self.RoundID,
                                self.RoundNum,
                                self.SuperItemID,
                                self.SuperItemCount,
                                self.SuperItemMoneyType,
                                self.SuperItemMoneyValue,
                                self.LVLimit,
                                self.BaseItemCount,
                                "...",
                                self.RandItemCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
#A1 25 ÇëÇóÇл»µØͼʧ°Ü#tagMCChangeMapFail

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

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

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x25
        return

    def GetLength(self):
        return sizeof(tagMCChangeMapFail)

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

    def OutputString(self):
        DumpString = '''//A1 25 ÇëÇóÇл»µØͼʧ°Ü//tagMCChangeMapFail:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


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


#------------------------------------------------------
# A1 10 ³äÖµ¹ºÂò´ÎÊýÐÅÏ¢ #tagMCCoinToGoldCountInfo

class  tagMCCoinToGoldCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RecordID", c_ushort),    
                  ("TodayPayCount", c_ushort),    # ½ñÈÕÒѹºÂò´ÎÊý
                  ("TotalPayCount", c_int),    # ÀÛ¼Æ×ܹºÂò´ÎÊý
                  ("WeekPayCount", c_ushort),    # ÖÜ×ܹºÂò´ÎÊý
                  ("MonthPayCount", c_ushort),    # ÔÂ×ܹºÂò´ÎÊý
                  ("SelectItemValue", c_int),    # ×ÔÑ¡ÎïÆ·Ë÷ÒýÖµ£¬Ã¿Á½Î»´æ´¢Ã¿¸ö×ÔÑ¡Ë÷Òý¶ÔӦѡÔñµÄÎïÆ·Ë÷Òý+1£¬´æ´¢Î»ÖµÎª0´ú±íδѡÔñ£¬×î¶àÖ§³ÖÑ¡Ôñ4ÖÖÎïÆ·
                  ]

    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.RecordID = 0
        self.TodayPayCount = 0
        self.TotalPayCount = 0
        self.WeekPayCount = 0
        self.MonthPayCount = 0
        self.SelectItemValue = 0
        return

    def GetLength(self):
        return sizeof(tagMCCoinToGoldCount)

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

    def OutputString(self):
        DumpString = '''// A1 10 ³äÖµ¹ºÂò´ÎÊýÐÅÏ¢ //tagMCCoinToGoldCountInfo:
                                RecordID:%d,
                                TodayPayCount:%d,
                                TotalPayCount:%d,
                                WeekPayCount:%d,
                                MonthPayCount:%d,
                                SelectItemValue:%d
                                '''\
                                %(
                                self.RecordID,
                                self.TodayPayCount,
                                self.TotalPayCount,
                                self.WeekPayCount,
                                self.MonthPayCount,
                                self.SelectItemValue
                                )
        return DumpString


class  tagMCCoinToGoldCountInfo(Structure):
    Head = tagHead()
    RecordCount = 0    #(WORD RecordCount)
    CTGCountInfoList = list()    #(vector<tagMCCoinToGoldCount> CTGCountInfoList)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RecordCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RecordCount):
            temCTGCountInfoList = tagMCCoinToGoldCount()
            _pos = temCTGCountInfoList.ReadData(_lpData, _pos)
            self.CTGCountInfoList.append(temCTGCountInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA1
        self.Head.SubCmd = 0x10
        self.RecordCount = 0
        self.CTGCountInfoList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
#A1 06 µã¾íת»¯Ôª±¦³äÖµ¼Ç¼ #tagMCCoinToGoldReport

class  tagMCCoinToGoldReport(Structure):
    Head = tagHead()
    OrderLen = 0    #(BYTE OrderLen)
    OrderID = ""    #(String OrderID)// ¶©µ¥id
    Coin = 0    #(DWORD Coin)// ³äÖµµÄµã¾í
    RecordID = 0    #(WORD RecordID)// ctgID
    OrderInfoLen = 0    #(BYTE OrderInfoLen)
    OrderInfo = ""    #(String OrderInfo)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA1
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OrderLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderID,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderLen)
        self.Coin,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RecordID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OrderInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderInfoLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA1
        self.Head.SubCmd = 0x06
        self.OrderLen = 0
        self.OrderID = ""
        self.Coin = 0
        self.RecordID = 0
        self.OrderInfoLen = 0
        self.OrderInfo = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.OrderLen)
        data = CommFunc.WriteString(data, self.OrderLen, self.OrderID)
        data = CommFunc.WriteDWORD(data, self.Coin)
        data = CommFunc.WriteWORD(data, self.RecordID)
        data = CommFunc.WriteBYTE(data, self.OrderInfoLen)
        data = CommFunc.WriteString(data, self.OrderInfoLen, self.OrderInfo)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OrderLen:%d,
                                OrderID:%s,
                                Coin:%d,
                                RecordID:%d,
                                OrderInfoLen:%d,
                                OrderInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OrderLen,
                                self.OrderID,
                                self.Coin,
                                self.RecordID,
                                self.OrderInfoLen,
                                self.OrderInfo
                                )
        return DumpString


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


#------------------------------------------------------
# A1 12 Íæ¼Ò³õʼ»¯ #tagMCDBPlayer

class  tagMCDBPlayer(Structure):
    Head = tagHead()
    AccID = ""    #(char AccID[65])//ÕʺÅÃû, ¸Ã½ÇÉ«ËùÔÚµÄÕʺŵÄÓû§Ãû
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])//size = 14
    AccState = 0    #(BYTE AccState)//0: δ´´½¨, 1: ´´½¨OK,Õý³£µÇ¼ 2:·âºÅ 3:ÒÑɾ³ý
    GMLevel = 0    #(BYTE GMLevel)//GMµÈ¼¶, 0:²»ÊÇGM  >=1 : GMµÄµÈ¼¶
    Sex = 0    #(BYTE Sex)//ÐÔ±ð
    Job = 0    #(BYTE Job)//Ö°Òµ, 0.ÐÂÊÖ 1.ÓÎÏÀ 2.սʿ 3.¹­¼ýÊÖ 4.ÊõÊ¿ 5.µÀÊ¿
    ReincarnationLv = 0    #(WORD ReincarnationLv)// תÉúµÈ¼¶
    LV = 0    #(WORD LV)//µÈ¼¶
    LVEx = 0    #(WORD LVEx)//Íæ¼ÒµÈ¼¶¸±±¾£¬ÓÃÓÚתÉú
    LV2 = 0    #(WORD LV2)//´óʦµÈ¼¶
    ExpPoint = 0    #(DWORD ExpPoint)//À©³ä¾­ÑéµãÊý
    TotalExp = 0    #(DWORD TotalExp)//×ܾ­Ñé
    Family = 0    #(DWORD Family)//¼Ò×å
    FamilyName = ""    #(char FamilyName[33])//¼Ò×åÃû³Æ
    TeamHornor = 0    #(int TeamHornor)//×é¶ÓÈÙÓþ
    FamilyHornor = 0    #(int FamilyHornor)//¼Ò×åÈÙÒ«
    FamilyActiveValue = 0    #(int FamilyActiveValue)//¼Ò×å»îÔ¾¶È
    LastWeekFamilyActiveValue = 0    #(int LastWeekFamilyActiveValue)//ÉÏÖܼÒ×å»îÔ¾¶È
    CountryHornor = 0    #(int CountryHornor)//±¾Öܹú¼Ò¹¦Ñ«Öµ
    CountryLastWeekHornor = 0    #(int CountryLastWeekHornor)//ÉÏÖܹú¼Ò¹¦Ñ«Öµ
    Mate = 0    #(DWORD Mate)
    Gold = 0    #(DWORD Gold)//½ð×Ó
    GoldPaper = 0    #(DWORD GoldPaper)//½ðƱ
    Silver = 0    #(DWORD Silver)//Òø×Ó
    SilverPaper = 0    #(DWORD SilverPaper)//񿮱
    FightPoint = 0    #(DWORD FightPoint)//Õ½¶·Öµ
    HappyPoint = 0    #(DWORD HappyPoint)//ÍÑ»ú¹Òʱ³¤£¨Ã룩
    LineID = 0    #(BYTE LineID)//½ÇÉ«ËùÔÚÏß·
    MapID = 0    #(WORD MapID)//½ÇÉ«ËùÔÚµØͼ
    PosX = 0    #(WORD PosX)//½ÇÉ«×ø±ê
    PosY = 0    #(WORD PosY)
    RebornMapID = 0    #(WORD RebornMapID)//ÖØÉúµãµØͼID
    RebornPosX = 0    #(WORD RebornPosX)
    RebornPosY = 0    #(WORD RebornPosY)
    State = 0    #(BYTE State)//½Çɫ״̬   0.Õý³£ÔÚÏß1.ÍÑ»ú¹ÒÔÚÏß 2ÍÑ»ú¹ÒËÀÍö
    HP = 0    #(DWORD HP)//µ±Ç°HP
    XP = 0    #(DWORD XP)//µ±Ç°XP
    HPRestoreSetting = 0    #(WORD HPRestoreSetting)//ÉÙÓÚÕâ¸öÖµ%×Ô¶¯ºÈѪ
    MPRestoreSetting = 0    #(WORD MPRestoreSetting)//ÉÙÓÚÕâ¸öÖµ%×Ô¶¯ºÈħ
    FreePoint = 0    #(DWORD FreePoint)//δ·ÖÅäµãÊý
    FreeSkillPoint = 0    #(DWORD FreeSkillPoint)//δ·ÖÅäµÄ¼¼Äܵã
    BaseSTR = 0    #(int BaseSTR)//ÂãÌåÁ¦Á¿
    BasePNE = 0    #(int BasePNE)//ÂãÌåÕæÔª
    BasePHY = 0    #(int BasePHY)//ÂãÌå½î¹Ç
    BaseCON = 0    #(int BaseCON)//ÂãÌåÌåÆÇ
    STR = 0    #(int STR)//Á¦Á¿
    PNE = 0    #(int PNE)//ÕæÔª
    PHY = 0    #(int PHY)//½î¹Ç
    CON = 0    #(int CON)//ÌåÆÇ
    PKValue = 0    #(WORD PKValue)//ºâÁ¿PKÄÜÁ¦µÄÒ»ÏîÊôÐÔ£¬Óɹ¥·À¼ÆËã¶øµÃ
    BackpackLV = 0    #(BYTE BackpackLV)//±³°üµÈ¼¶
    WarehouseLV = 0    #(BYTE WarehouseLV)//²Ö¿âµÈ¼¶
    TeamID = 0    #(DWORD TeamID)//¶ÓÎéID
    UseGoldType = 0    #(BYTE UseGoldType)//ĬÈÏÓýð×Ó/½ðƱ		ÀàÐÍΪMoneyType
    UseSilverType = 0    #(BYTE UseSilverType)//ĬÈÏÓõÄÒø×Ó/ÒøƱ
    AttackMode = 0    #(BYTE AttackMode)//¹¥»÷ģʽ
    LastWeekOnlineTime = 0    #(DWORD LastWeekOnlineTime)//ÉÏÖÜÔÚÏßʱ¼ä
    FBID = 0    #(BYTE FBID)//fb id
    FamilyLV = 0    #(BYTE FamilyLV)//¼Ò×åµÈ¼¶
    FriendFavor = 0    #(DWORD FriendFavor)//ºÃÓÑÈËÆøÖµ
    Energy = 0    #(DWORD Energy)//¾«Á¦Öµ
    EquipShowSwitch = 0    #(DWORD EquipShowSwitch)//×°±¸ÏÔʾ¿ª¹Ø
    LuckValue = 0    #(DWORD LuckValue)//ÐÒÔËÖµ
    ExAttr1 = 0    #(DWORD ExAttr1)//À©Õ¹ÊôÐÔ1£¬¸÷ÏîĿרÓÃ
    ExAttr2 = 0    #(DWORD ExAttr2)//À©Õ¹ÊôÐÔ2£¬¸÷ÏîĿרÓÃ
    ExAttr3 = 0    #(DWORD ExAttr3)//À©Õ¹ÊôÐÔ3£¬¸÷ÏîĿרÓÃ
    ExAttr4 = 0    #(DWORD ExAttr4)//À©Õ¹ÊôÐÔ4£¬¸÷ÏîĿרÓÃ
    ExAttr5 = 0    #(DWORD ExAttr5)//À©Õ¹ÊôÐÔ5£¬¸÷ÏîĿרÓÃ
    Faction = 0    #(BYTE Faction)//ÕóÓª
    InfamyValue = 0    #(DWORD InfamyValue)//¶ñÃûÖµ
    OfficialRank = 0    #(BYTE OfficialRank)//¹Ù½×£¬¹ÙÖ°µÈ¼¶
    ChangeCoinPointTotal = 0    #(DWORD ChangeCoinPointTotal)//¶Ò»»µÄµãÊý×ܼÆ
    VIPLv = 0    #(BYTE VIPLv)//VIPµÈ¼¶
    VIPLvForPhone = 0    #(BYTE VIPLvForPhone)//Òƶ¯VIPµÈ¼¶
    ExAttr6 = 0    #(DWORD ExAttr6)//À©Õ¹ÊôÐÔ6£¬¸÷ÏîĿרÓÃ
    ExAttr7 = 0    #(DWORD ExAttr7)//À©Õ¹ÊôÐÔ7£¬¸÷ÏîĿרÓÃ
    ExAttr8 = 0    #(DWORD ExAttr8)//À©Õ¹ÊôÐÔ8£¬¸÷ÏîĿרÓÃ
    ExAttr9 = 0    #(DWORD ExAttr9)//À©Õ¹ÊôÐÔ9£¬¸÷ÏîĿרÓÃ
    ExAttr10 = 0    #(DWORD ExAttr10)//À©Õ¹ÊôÐÔ10£¬¸÷ÏîĿרÓÃ
    ModelMark = 0    #(DWORD ModelMark)// ±äÐÎÄ£ÐÍmark
    ExAttr11 = 0    #(DWORD ExAttr11)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr12 = 0    #(DWORD ExAttr12)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr13 = 0    #(DWORD ExAttr13)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr14 = 0    #(DWORD ExAttr14)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    OperateInfo = 0    #(DWORD OperateInfo)//Íæ¼Ò¸½¼ÓÔËÓªÉÌÐÅÏ¢
    Operate = ""    #(char Operate[15])//ËùÊôÔËÓªÉÌƽ̨Ãû
    ServerID = 0    #(DWORD ServerID)//ËùÊôÇø·þID
    ExAttr15 = 0    #(DWORD ExAttr15)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr16 = 0    #(DWORD ExAttr16)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr17 = 0    #(DWORD ExAttr17)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr18 = 0    #(DWORD ExAttr18)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr19 = 0    #(DWORD ExAttr19)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    ExAttr20 = 0    #(DWORD ExAttr20)//Ô¤ÁôµÄÀ©Õ¹ÊôÐÔ×ֶΣ¬ÓÃÀ´´æ·ÅÏîÄ¿Ìض¨µÄÊôÐÔ
    HPEx = 0    #(DWORD HPEx)//µ±Ç°ÑªÁ¿ ³¬¹ýEµÄ¼Ç¼
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    RoleType = 0    #(DWORD RoleType)//½ÇÉ«ÀàÐÍ£¨¸÷ÏîÄ¿¿É×Ô¶¨Ò庬Ò壬ÈçÖÖ×壬ÓëÖ°ÒµÇø·Ö£©
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.AccState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GMLevel,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Sex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ReincarnationLv,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LVEx,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LV2,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Family,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FamilyName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.TeamHornor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FamilyHornor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FamilyActiveValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LastWeekFamilyActiveValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountryHornor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountryLastWeekHornor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Mate,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Gold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GoldPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Silver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SilverPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HappyPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RebornMapID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RebornPosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RebornPosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.State,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.XP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HPRestoreSetting,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.MPRestoreSetting,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FreePoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FreeSkillPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BaseSTR,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BasePNE,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BasePHY,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BaseCON,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.STR,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PNE,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PHY,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CON,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PKValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BackpackLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WarehouseLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UseGoldType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.UseSilverType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AttackMode,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LastWeekOnlineTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FBID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FamilyLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FriendFavor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Energy,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipShowSwitch,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.LuckValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Faction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.InfamyValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.OfficialRank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ChangeCoinPointTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.VIPLv,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.VIPLvForPhone,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExAttr6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr9,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr10,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ModelMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr11,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr12,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr13,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr14,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.OperateInfo,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Operate,_pos = CommFunc.ReadString(_lpData, _pos,15)
        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr15,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr16,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr17,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr18,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr19,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExAttr20,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RoleType,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA1
        self.Head.SubCmd = 0x12
        self.AccID = ""
        self.PlayerID = 0
        self.PlayerName = ""
        self.AccState = 0
        self.GMLevel = 0
        self.Sex = 0
        self.Job = 0
        self.ReincarnationLv = 0
        self.LV = 0
        self.LVEx = 0
        self.LV2 = 0
        self.ExpPoint = 0
        self.TotalExp = 0
        self.Family = 0
        self.FamilyName = ""
        self.TeamHornor = 0
        self.FamilyHornor = 0
        self.FamilyActiveValue = 0
        self.LastWeekFamilyActiveValue = 0
        self.CountryHornor = 0
        self.CountryLastWeekHornor = 0
        self.Mate = 0
        self.Gold = 0
        self.GoldPaper = 0
        self.Silver = 0
        self.SilverPaper = 0
        self.FightPoint = 0
        self.HappyPoint = 0
        self.LineID = 0
        self.MapID = 0
        self.PosX = 0
        self.PosY = 0
        self.RebornMapID = 0
        self.RebornPosX = 0
        self.RebornPosY = 0
        self.State = 0
        self.HP = 0
        self.XP = 0
        self.HPRestoreSetting = 0
        self.MPRestoreSetting = 0
        self.FreePoint = 0
        self.FreeSkillPoint = 0
        self.BaseSTR = 0
        self.BasePNE = 0
        self.BasePHY = 0
        self.BaseCON = 0
        self.STR = 0
        self.PNE = 0
        self.PHY = 0
        self.CON = 0
        self.PKValue = 0
        self.BackpackLV = 0
        self.WarehouseLV = 0
        self.TeamID = 0
        self.UseGoldType = 0
        self.UseSilverType = 0
        self.AttackMode = 0
        self.LastWeekOnlineTime = 0
        self.FBID = 0
        self.FamilyLV = 0
        self.FriendFavor = 0
        self.Energy = 0
        self.EquipShowSwitch = 0
        self.LuckValue = 0
        self.ExAttr1 = 0
        self.ExAttr2 = 0
        self.ExAttr3 = 0
        self.ExAttr4 = 0
        self.ExAttr5 = 0
        self.Faction = 0
        self.InfamyValue = 0
        self.OfficialRank = 0
        self.ChangeCoinPointTotal = 0
        self.VIPLv = 0
        self.VIPLvForPhone = 0
        self.ExAttr6 = 0
        self.ExAttr7 = 0
        self.ExAttr8 = 0
        self.ExAttr9 = 0
        self.ExAttr10 = 0
        self.ModelMark = 0
        self.ExAttr11 = 0
        self.ExAttr12 = 0
        self.ExAttr13 = 0
        self.ExAttr14 = 0
        self.OperateInfo = 0
        self.Operate = ""
        self.ServerID = 0
        self.ExAttr15 = 0
        self.ExAttr16 = 0
        self.ExAttr17 = 0
        self.ExAttr18 = 0
        self.ExAttr19 = 0
        self.ExAttr20 = 0
        self.HPEx = 0
        self.Face = 0
        self.FacePic = 0
        self.RoleType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 65
        length += 4
        length += 33
        length += 1
        length += 1
        length += 1
        length += 1
        length += 2
        length += 2
        length += 2
        length += 2
        length += 4
        length += 4
        length += 4
        length += 33
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        length += 1
        length += 4
        length += 4
        length += 2
        length += 2
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 2
        length += 1
        length += 1
        length += 4
        length += 1
        length += 1
        length += 1
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        length += 4
        length += 1
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 15
        length += 4
        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.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 65, self.AccID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.AccState)
        data = CommFunc.WriteBYTE(data, self.GMLevel)
        data = CommFunc.WriteBYTE(data, self.Sex)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.ReincarnationLv)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.LVEx)
        data = CommFunc.WriteWORD(data, self.LV2)
        data = CommFunc.WriteDWORD(data, self.ExpPoint)
        data = CommFunc.WriteDWORD(data, self.TotalExp)
        data = CommFunc.WriteDWORD(data, self.Family)
        data = CommFunc.WriteString(data, 33, self.FamilyName)
        data = CommFunc.WriteDWORD(data, self.TeamHornor)
        data = CommFunc.WriteDWORD(data, self.FamilyHornor)
        data = CommFunc.WriteDWORD(data, self.FamilyActiveValue)
        data = CommFunc.WriteDWORD(data, self.LastWeekFamilyActiveValue)
        data = CommFunc.WriteDWORD(data, self.CountryHornor)
        data = CommFunc.WriteDWORD(data, self.CountryLastWeekHornor)
        data = CommFunc.WriteDWORD(data, self.Mate)
        data = CommFunc.WriteDWORD(data, self.Gold)
        data = CommFunc.WriteDWORD(data, self.GoldPaper)
        data = CommFunc.WriteDWORD(data, self.Silver)
        data = CommFunc.WriteDWORD(data, self.SilverPaper)
        data = CommFunc.WriteDWORD(data, self.FightPoint)
        data = CommFunc.WriteDWORD(data, self.HappyPoint)
        data = CommFunc.WriteBYTE(data, self.LineID)
        data = CommFunc.WriteWORD(data, self.MapID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteWORD(data, self.RebornMapID)
        data = CommFunc.WriteWORD(data, self.RebornPosX)
        data = CommFunc.WriteWORD(data, self.RebornPosY)
        data = CommFunc.WriteBYTE(data, self.State)
        data = CommFunc.WriteDWORD(data, self.HP)
        data = CommFunc.WriteDWORD(data, self.XP)
        data = CommFunc.WriteWORD(data, self.HPRestoreSetting)
        data = CommFunc.WriteWORD(data, self.MPRestoreSetting)
        data = CommFunc.WriteDWORD(data, self.FreePoint)
        data = CommFunc.WriteDWORD(data, self.FreeSkillPoint)
        data = CommFunc.WriteDWORD(data, self.BaseSTR)
        data = CommFunc.WriteDWORD(data, self.BasePNE)
        data = CommFunc.WriteDWORD(data, self.BasePHY)
        data = CommFunc.WriteDWORD(data, self.BaseCON)
        data = CommFunc.WriteDWORD(data, self.STR)
        data = CommFunc.WriteDWORD(data, self.PNE)
        data = CommFunc.WriteDWORD(data, self.PHY)
        data = CommFunc.WriteDWORD(data, self.CON)
        data = CommFunc.WriteWORD(data, self.PKValue)
        data = CommFunc.WriteBYTE(data, self.BackpackLV)
        data = CommFunc.WriteBYTE(data, self.WarehouseLV)
        data = CommFunc.WriteDWORD(data, self.TeamID)
        data = CommFunc.WriteBYTE(data, self.UseGoldType)
        data = CommFunc.WriteBYTE(data, self.UseSilverType)
        data = CommFunc.WriteBYTE(data, self.AttackMode)
        data = CommFunc.WriteDWORD(data, self.LastWeekOnlineTime)
        data = CommFunc.WriteBYTE(data, self.FBID)
        data = CommFunc.WriteBYTE(data, self.FamilyLV)
        data = CommFunc.WriteDWORD(data, self.FriendFavor)
        data = CommFunc.WriteDWORD(data, self.Energy)
        data = CommFunc.WriteDWORD(data, self.EquipShowSwitch)
        data = CommFunc.WriteDWORD(data, self.LuckValue)
        data = CommFunc.WriteDWORD(data, self.ExAttr1)
        data = CommFunc.WriteDWORD(data, self.ExAttr2)
        data = CommFunc.WriteDWORD(data, self.ExAttr3)
        data = CommFunc.WriteDWORD(data, self.ExAttr4)
        data = CommFunc.WriteDWORD(data, self.ExAttr5)
        data = CommFunc.WriteBYTE(data, self.Faction)
        data = CommFunc.WriteDWORD(data, self.InfamyValue)
        data = CommFunc.WriteBYTE(data, self.OfficialRank)
        data = CommFunc.WriteDWORD(data, self.ChangeCoinPointTotal)
        data = CommFunc.WriteBYTE(data, self.VIPLv)
        data = CommFunc.WriteBYTE(data, self.VIPLvForPhone)
        data = CommFunc.WriteDWORD(data, self.ExAttr6)
        data = CommFunc.WriteDWORD(data, self.ExAttr7)
        data = CommFunc.WriteDWORD(data, self.ExAttr8)
        data = CommFunc.WriteDWORD(data, self.ExAttr9)
        data = CommFunc.WriteDWORD(data, self.ExAttr10)
        data = CommFunc.WriteDWORD(data, self.ModelMark)
        data = CommFunc.WriteDWORD(data, self.ExAttr11)
        data = CommFunc.WriteDWORD(data, self.ExAttr12)
        data = CommFunc.WriteDWORD(data, self.ExAttr13)
        data = CommFunc.WriteDWORD(data, self.ExAttr14)
        data = CommFunc.WriteDWORD(data, self.OperateInfo)
        data = CommFunc.WriteString(data, 15, self.Operate)
        data = CommFunc.WriteDWORD(data, self.ServerID)
        data = CommFunc.WriteDWORD(data, self.ExAttr15)
        data = CommFunc.WriteDWORD(data, self.ExAttr16)
        data = CommFunc.WriteDWORD(data, self.ExAttr17)
        data = CommFunc.WriteDWORD(data, self.ExAttr18)
        data = CommFunc.WriteDWORD(data, self.ExAttr19)
        data = CommFunc.WriteDWORD(data, self.ExAttr20)
        data = CommFunc.WriteDWORD(data, self.HPEx)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.RoleType)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AccID:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                AccState:%d,
                                GMLevel:%d,
                                Sex:%d,
                                Job:%d,
                                ReincarnationLv:%d,
                                LV:%d,
                                LVEx:%d,
                                LV2:%d,
                                ExpPoint:%d,
                                TotalExp:%d,
                                Family:%d,
                                FamilyName:%s,
                                TeamHornor:%d,
                                FamilyHornor:%d,
                                FamilyActiveValue:%d,
                                LastWeekFamilyActiveValue:%d,
                                CountryHornor:%d,
                                CountryLastWeekHornor:%d,
                                Mate:%d,
                                Gold:%d,
                                GoldPaper:%d,
                                Silver:%d,
                                SilverPaper:%d,
                                FightPoint:%d,
                                HappyPoint:%d,
                                LineID:%d,
                                MapID:%d,
                                PosX:%d,
                                PosY:%d,
                                RebornMapID:%d,
                                RebornPosX:%d,
                                RebornPosY:%d,
                                State:%d,
                                HP:%d,
                                XP:%d,
                                HPRestoreSetting:%d,
                                MPRestoreSetting:%d,
                                FreePoint:%d,
                                FreeSkillPoint:%d,
                                BaseSTR:%d,
                                BasePNE:%d,
                                BasePHY:%d,
                                BaseCON:%d,
                                STR:%d,
                                PNE:%d,
                                PHY:%d,
                                CON:%d,
                                PKValue:%d,
                                BackpackLV:%d,
                                WarehouseLV:%d,
                                TeamID:%d,
                                UseGoldType:%d,
                                UseSilverType:%d,
                                AttackMode:%d,
                                LastWeekOnlineTime:%d,
                                FBID:%d,
                                FamilyLV:%d,
                                FriendFavor:%d,
                                Energy:%d,
                                EquipShowSwitch:%d,
                                LuckValue:%d,
                                ExAttr1:%d,
                                ExAttr2:%d,
                                ExAttr3:%d,
                                ExAttr4:%d,
                                ExAttr5:%d,
                                Faction:%d,
                                InfamyValue:%d,
                                OfficialRank:%d,
                                ChangeCoinPointTotal:%d,
                                VIPLv:%d,
                                VIPLvForPhone:%d,
                                ExAttr6:%d,
                                ExAttr7:%d,
                                ExAttr8:%d,
                                ExAttr9:%d,
                                ExAttr10:%d,
                                ModelMark:%d,
                                ExAttr11:%d,
                                ExAttr12:%d,
                                ExAttr13:%d,
                                ExAttr14:%d,
                                OperateInfo:%d,
                                Operate:%s,
                                ServerID:%d,
                                ExAttr15:%d,
                                ExAttr16:%d,
                                ExAttr17:%d,
                                ExAttr18:%d,
                                ExAttr19:%d,
                                ExAttr20:%d,
                                HPEx:%d,
                                Face:%d,
                                FacePic:%d,
                                RoleType:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AccID,
                                self.PlayerID,
                                self.PlayerName,
                                self.AccState,
                                self.GMLevel,
                                self.Sex,
                                self.Job,
                                self.ReincarnationLv,
                                self.LV,
                                self.LVEx,
                                self.LV2,
                                self.ExpPoint,
                                self.TotalExp,
                                self.Family,
                                self.FamilyName,
                                self.TeamHornor,
                                self.FamilyHornor,
                                self.FamilyActiveValue,
                                self.LastWeekFamilyActiveValue,
                                self.CountryHornor,
                                self.CountryLastWeekHornor,
                                self.Mate,
                                self.Gold,
                                self.GoldPaper,
                                self.Silver,
                                self.SilverPaper,
                                self.FightPoint,
                                self.HappyPoint,
                                self.LineID,
                                self.MapID,
                                self.PosX,
                                self.PosY,
                                self.RebornMapID,
                                self.RebornPosX,
                                self.RebornPosY,
                                self.State,
                                self.HP,
                                self.XP,
                                self.HPRestoreSetting,
                                self.MPRestoreSetting,
                                self.FreePoint,
                                self.FreeSkillPoint,
                                self.BaseSTR,
                                self.BasePNE,
                                self.BasePHY,
                                self.BaseCON,
                                self.STR,
                                self.PNE,
                                self.PHY,
                                self.CON,
                                self.PKValue,
                                self.BackpackLV,
                                self.WarehouseLV,
                                self.TeamID,
                                self.UseGoldType,
                                self.UseSilverType,
                                self.AttackMode,
                                self.LastWeekOnlineTime,
                                self.FBID,
                                self.FamilyLV,
                                self.FriendFavor,
                                self.Energy,
                                self.EquipShowSwitch,
                                self.LuckValue,
                                self.ExAttr1,
                                self.ExAttr2,
                                self.ExAttr3,
                                self.ExAttr4,
                                self.ExAttr5,
                                self.Faction,
                                self.InfamyValue,
                                self.OfficialRank,
                                self.ChangeCoinPointTotal,
                                self.VIPLv,
                                self.VIPLvForPhone,
                                self.ExAttr6,
                                self.ExAttr7,
                                self.ExAttr8,
                                self.ExAttr9,
                                self.ExAttr10,
                                self.ModelMark,
                                self.ExAttr11,
                                self.ExAttr12,
                                self.ExAttr13,
                                self.ExAttr14,
                                self.OperateInfo,
                                self.Operate,
                                self.ServerID,
                                self.ExAttr15,
                                self.ExAttr16,
                                self.ExAttr17,
                                self.ExAttr18,
                                self.ExAttr19,
                                self.ExAttr20,
                                self.HPEx,
                                self.Face,
                                self.FacePic,
                                self.RoleType
                                )
        return DumpString


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


#------------------------------------------------------
#A1 05 Ôª±¦Ïû·Ñ¼Ç¼ #tagMCGoldCostReport

class  tagMCGoldCostReport(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CostType", c_int),    # Ïû·Ñµã±ê¼Ç
                  ("ItemID", c_int),    # Ïû·ÑµÄÎïÆ·id
                  ("Price", c_int),    # Ïû·ÑÔª±¦Êý
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x05
        self.CostType = 0
        self.ItemID = 0
        self.Price = 0
        return

    def GetLength(self):
        return sizeof(tagMCGoldCostReport)

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

    def OutputString(self):
        DumpString = '''//A1 05 Ôª±¦Ïû·Ñ¼Ç¼ //tagMCGoldCostReport:
                                Cmd:%s,
                                SubCmd:%s,
                                CostType:%d,
                                ItemID:%d,
                                Price:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CostType,
                                self.ItemID,
                                self.Price
                                )
        return DumpString


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


#------------------------------------------------------
#A1 02 ÈÎÎñ»ñµÃÎïÆ·ÏÔʾ #tagMCItemShowInTask

class  tagMCItemShowInTask(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Type", c_ubyte),    ##ÎïÆ·ÀàÐÍ£¬¼¼ÄÜ:0£¬×°±¸:1£¬³èÎï:2£¬×øÆï:3£¬ÆäËû:4
                  ("ID", c_int),    #ÎïÆ·ID
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x02
        self.Type = 0
        self.ID = 0
        return

    def GetLength(self):
        return sizeof(tagMCItemShowInTask)

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

    def OutputString(self):
        DumpString = '''//A1 02 ÈÎÎñ»ñµÃÎïÆ·ÏÔʾ //tagMCItemShowInTask:
                                Cmd:%s,
                                SubCmd:%s,
                                Type:%d,
                                ID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Type,
                                self.ID
                                )
        return DumpString


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


#------------------------------------------------------
# A1 09 Íæ¼ÒÀÛ¼ÆÔÚÏßʱ³¤ #tagMCOnLineTimeTotal

class  tagMCOnLineTimeTotal(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("OnLineTimeTotal", c_int),    #ÀÛ¼ÆÔÚÏßʱ³¤£¨Ã룩
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x09
        self.OnLineTimeTotal = 0
        return

    def GetLength(self):
        return sizeof(tagMCOnLineTimeTotal)

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

    def OutputString(self):
        DumpString = '''// A1 09 Íæ¼ÒÀÛ¼ÆÔÚÏßʱ³¤ //tagMCOnLineTimeTotal:
                                Cmd:%s,
                                SubCmd:%s,
                                OnLineTimeTotal:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.OnLineTimeTotal
                                )
        return DumpString


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


#------------------------------------------------------
#A1 07 Íæ¼ÒµôÂÊ¼Ó³É #tagMCPlayerDropRate

class  tagMCPlayerDropRate(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("WorldDropRate", c_ushort),    #È«·þ»î¶¯¼Ó³É
                  ("WorldBossRate", c_ushort),    #ÊÀ½çboss¼Ó³É
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA1
        self.SubCmd = 0x07
        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 = 0xA1
        self.SubCmd = 0x07
        self.WorldDropRate = 0
        self.WorldBossRate = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerDropRate)

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

    def OutputString(self):
        DumpString = '''//A1 07 Íæ¼ÒµôÂÊ¼Ó³É //tagMCPlayerDropRate:
                                Cmd:%s,
                                SubCmd:%s,
                                WorldDropRate:%d,
                                WorldBossRate:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.WorldDropRate,
                                self.WorldBossRate
                                )
        return DumpString


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


#------------------------------------------------------
# A1 24 Íæ¼Ò³õʼ»¯À©Õ¹ÐÅÏ¢ #tagMCPlayerInfo

class  tagMCPlayerInfo(Structure):
    Head = tagHead()
    IsAdult = 0    #(BYTE IsAdult)//ÊÇ·ñ³ÉÄê
    CreateRoleTime = ""    #(char CreateRoleTime[19])
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.IsAdult,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CreateRoleTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA1
        self.Head.SubCmd = 0x24
        self.IsAdult = 0
        self.CreateRoleTime = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsAdult)
        data = CommFunc.WriteString(data, 19, self.CreateRoleTime)
        return data

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


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


#------------------------------------------------------
#A1 01 Ö÷½ÇÍ˳öÕ½¶·×´Ì¬ #tagPlayerLeaveBattle

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

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA1
        self.SubCmd = 0x01
        return

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x01
        return

    def GetLength(self):
        return sizeof(tagPlayerLeaveBattle)

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

    def OutputString(self):
        DumpString = '''//A1 01 Ö÷½ÇÍ˳öÕ½¶·×´Ì¬ //tagPlayerLeaveBattle:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


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


#------------------------------------------------------
#A1 26 ×¼±¸Çл»µØͼ #tagMCPrepareChangeMap

class  tagMCPrepareChangeMap(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MapID", c_ushort),    
                  ("FuncLineID", c_ushort),    #¹¦ÄÜÏß·ID
                  ]

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

    def GetLength(self):
        return sizeof(tagMCPrepareChangeMap)

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

    def OutputString(self):
        DumpString = '''//A1 26 ×¼±¸Çл»µØͼ //tagMCPrepareChangeMap:
                                Cmd:%s,
                                SubCmd:%s,
                                MapID:%d,
                                FuncLineID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MapID,
                                self.FuncLineID
                                )
        return DumpString


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


#------------------------------------------------------
#A1 27 ¿ªÊ¼Çл»µØͼ #tagMCStartChangeMap

class  tagMCStartChangeMap(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MapID", c_int),    
                  ("FuncLineID", c_ushort),    #¹¦ÄÜÏß·ID
                  ]

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

    def GetLength(self):
        return sizeof(tagMCStartChangeMap)

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

    def OutputString(self):
        DumpString = '''//A1 27 ¿ªÊ¼Çл»µØͼ //tagMCStartChangeMap:
                                Cmd:%s,
                                SubCmd:%s,
                                MapID:%d,
                                FuncLineID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MapID,
                                self.FuncLineID
                                )
        return DumpString


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


#------------------------------------------------------
#A1 23 ½ÇÉ«¸ÄÃû´ÎÊý #tagUpdatePlayerNameCount

class  tagUpdatePlayerNameCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Count", c_int),    #¸ÄÃû´ÎÊý
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA1
        self.SubCmd = 0x23
        self.Count = 0
        return

    def GetLength(self):
        return sizeof(tagUpdatePlayerNameCount)

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

    def OutputString(self):
        DumpString = '''//A1 23 ½ÇÉ«¸ÄÃû´ÎÊý //tagUpdatePlayerNameCount:
                                Cmd:%s,
                                SubCmd:%s,
                                Count:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Count
                                )
        return DumpString


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


#------------------------------------------------------
# A2 02 Íæ¼Ò¹¥»÷ģʽ֪ͨ #tagMCAttackMode

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

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

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

    def Clear(self):
        self.Cmd = 0xA2
        self.SubCmd = 0x02
        self.Mode = 0
        return

    def GetLength(self):
        return sizeof(tagMCAttackMode)

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

    def OutputString(self):
        DumpString = '''// A2 02 Íæ¼Ò¹¥»÷ģʽ֪ͨ //tagMCAttackMode:
                                Cmd:%s,
                                SubCmd:%s,
                                Mode:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Mode
                                )
        return DumpString


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


#------------------------------------------------------
# A2 06 ×Ô¶¯×ª»¯Îª¶ÔÓ¦ÎïÆ·ID¸öÊýˢР#tagMCAutoItemCountRefresh

class  tagMCAutoItemCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", 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.ItemID = 0
        self.ItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCAutoItemCount)

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

    def OutputString(self):
        DumpString = '''// A2 06 ×Ô¶¯×ª»¯Îª¶ÔÓ¦ÎïÆ·ID¸öÊýˢР//tagMCAutoItemCountRefresh:
                                ItemID:%d,
                                ItemCount:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount
                                )
        return DumpString


class  tagMCAutoItemCountRefresh(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)// ˢиöÊý
    ItemCountList = list()    #(vector<tagMCAutoItemCount> ItemCountList)// ÎïÆ·ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA2
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temItemCountList = tagMCAutoItemCount()
            _pos = temItemCountList.ReadData(_lpData, _pos)
            self.ItemCountList.append(temItemCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA2
        self.Head.SubCmd = 0x06
        self.Count = 0
        self.ItemCountList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A2 03 ×îºóÒ»´Î±³°ü¿ª¸ñµÄÔÚÏßʱ¼ä #tagMCOnlineTimeLastOpenPack

class  tagMCOnlineTimeLastOpenPack(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PackType", c_ubyte),    #±³°üÀàÐÍ
                  ("LastOnLineTime", c_int),    #ÉÏÒ»´Î±³°ü¿ª¸ñÔÚÏßʱ³¤
                  ]

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

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

    def Clear(self):
        self.Cmd = 0xA2
        self.SubCmd = 0x03
        self.PackType = 0
        self.LastOnLineTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCOnlineTimeLastOpenPack)

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

    def OutputString(self):
        DumpString = '''// A2 03 ×îºóÒ»´Î±³°ü¿ª¸ñµÄÔÚÏßʱ¼ä //tagMCOnlineTimeLastOpenPack:
                                Cmd:%s,
                                SubCmd:%s,
                                PackType:%d,
                                LastOnLineTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PackType,
                                self.LastOnLineTime
                                )
        return DumpString


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


#------------------------------------------------------
# A2 05 ÐéÄâ±³°üÎïÆ·Çå¿Õ #tagMCVPackClear

class  tagMCVPackClear(Structure):
    Head = tagHead()
    PackType = 0    #(BYTE PackType)//±³°üÀàÐÍ
    Count = 0    #(WORD Count)
    ItemPlaceList = list()    #(vector<WORD> ItemPlaceList)//Çå¿Õ¸ñ×ÓË÷ÒýÁбí, size = Count
    data = None

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

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

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA2
        self.Head.SubCmd = 0x05
        self.PackType = 0
        self.Count = 0
        self.ItemPlaceList = list()
        return

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

        return length

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

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


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


#------------------------------------------------------
# A2 04 ÐéÄâ±³°üÎïƷˢР#tagMCVPackRefresh

class  tagMCVPackItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemPlace", c_ushort),    # ±³°üÎïƷλÖÃË÷Òý
                  ("ItemData", 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.ItemPlace = 0
        self.ItemData = 0
        return

    def GetLength(self):
        return sizeof(tagMCVPackItem)

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

    def OutputString(self):
        DumpString = '''// A2 04 ÐéÄâ±³°üÎïƷˢР//tagMCVPackRefresh:
                                ItemPlace:%d,
                                ItemData:%d
                                '''\
                                %(
                                self.ItemPlace,
                                self.ItemData
                                )
        return DumpString


class  tagMCVPackRefresh(Structure):
    Head = tagHead()
    PackType = 0    #(BYTE PackType)//±³°üÀàÐÍ
    Count = 0    #(WORD Count)// ˢиöÊý
    VPacklItemList = list()    #(vector<tagMCVPackItem> VPacklItemList)// ÎïÆ·ÐÅÏ¢Áбí
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PackType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temVPacklItemList = tagMCVPackItem()
            _pos = temVPacklItemList.ReadData(_lpData, _pos)
            self.VPacklItemList.append(temVPacklItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA2
        self.Head.SubCmd = 0x04
        self.PackType = 0
        self.Count = 0
        self.VPacklItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 2
        for i in range(self.Count):
            length += self.VPacklItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PackType)
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.VPacklItemList[i].GetLength(), self.VPacklItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PackType:%d,
                                Count:%d,
                                VPacklItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PackType,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCVPackRefresh=tagMCVPackRefresh()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCVPackRefresh.Head.Cmd,m_NAtagMCVPackRefresh.Head.SubCmd))] = m_NAtagMCVPackRefresh


#------------------------------------------------------
#A2 01 Íæ¼Ò²Ö¿âËø¶¨×´Ì¬ #tagMCWarehorseLock

class  tagMCWarehorseLock(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LockState", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA2
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA2
        self.SubCmd = 0x01
        self.LockState = 0
        return

    def GetLength(self):
        return sizeof(tagMCWarehorseLock)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A2 01 Íæ¼Ò²Ö¿âËø¶¨×´Ì¬ //tagMCWarehorseLock:
                                Cmd:%s,
                                SubCmd:%s,
                                LockState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LockState
                                )
        return DumpString


m_NAtagMCWarehorseLock=tagMCWarehorseLock()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCWarehorseLock.Cmd,m_NAtagMCWarehorseLock.SubCmd))] = m_NAtagMCWarehorseLock


#------------------------------------------------------
#A3 30 ¹ºÂòħ»êÍ­Ç®¾­ÑéʲôµÄ֪ͨ #tagMCBuySomething

class  tagMCSingleBuySomethingInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    #14Í­Ç®£¬15¾­Ñé
                  ("BuyCnt", c_ubyte),    #½ñÈÕÒѹºÂò´ÎÊý
                  ("HistoryBuyCnt", c_ubyte),    #ÀúÊ·ÒѹºÂò´ÎÊý
                  ("LastFreeTime", 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.Type = 0
        self.BuyCnt = 0
        self.HistoryBuyCnt = 0
        self.LastFreeTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCSingleBuySomethingInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 30 ¹ºÂòħ»êÍ­Ç®¾­ÑéʲôµÄ֪ͨ //tagMCBuySomething:
                                Type:%d,
                                BuyCnt:%d,
                                HistoryBuyCnt:%d,
                                LastFreeTime:%d
                                '''\
                                %(
                                self.Type,
                                self.BuyCnt,
                                self.HistoryBuyCnt,
                                self.LastFreeTime
                                )
        return DumpString


class  tagMCBuySomething(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)//ÐÅÏ¢Êý
    Infos = list()    #(vector<tagMCSingleBuySomethingInfo> Infos)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x30
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfos = tagMCSingleBuySomethingInfo()
            _pos = temInfos.ReadData(_lpData, _pos)
            self.Infos.append(temInfos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x30
        self.Cnt = 0
        self.Infos = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.Infos[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.Infos[i].GetLength(), self.Infos[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                Infos:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCBuySomething=tagMCBuySomething()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBuySomething.Head.Cmd,m_NAtagMCBuySomething.Head.SubCmd))] = m_NAtagMCBuySomething


#------------------------------------------------------
# A3 17 È«ÉíÊôÐÔ¼¤»îÊýÁ¿Í¨Öª #tagMCAllEquipAttrActiveInfo

class  tagMCEquipActiveInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    # 0Ç¿»¯ 1ÐÇÊý
                  ("Cnt", 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.Type = 0
        self.Cnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCEquipActiveInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 17 È«ÉíÊôÐÔ¼¤»îÊýÁ¿Í¨Öª //tagMCAllEquipAttrActiveInfo:
                                Type:%d,
                                Cnt:%d
                                '''\
                                %(
                                self.Type,
                                self.Cnt
                                )
        return DumpString


class  tagMCAllEquipAttrActiveInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ¸öÊý
    ActiveInfo = list()    #(vector<tagMCEquipActiveInfo> ActiveInfo)//ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temActiveInfo = tagMCEquipActiveInfo()
            _pos = temActiveInfo.ReadData(_lpData, _pos)
            self.ActiveInfo.append(temActiveInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x17
        self.Count = 0
        self.ActiveInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.ActiveInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ActiveInfo[i].GetLength(), self.ActiveInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ActiveInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCAllEquipAttrActiveInfo=tagMCAllEquipAttrActiveInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAllEquipAttrActiveInfo.Head.Cmd,m_NAtagMCAllEquipAttrActiveInfo.Head.SubCmd))] = m_NAtagMCAllEquipAttrActiveInfo


#------------------------------------------------------
# A3 C3 ¾º¼¼³¡Íæ¼ÒÐÅÏ¢ #tagMCArenaPlayerInfo

class  tagMCArenaPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsReset", c_ubyte),    #ÊÇ·ñÊÇÖØÖõÄ
                  ("Score", c_int),    #µ±Ç°»ý·Ö
                  ("BattleCountToday", c_ubyte),    #½ñÈÕÒÑÌôÕ½´ÎÊý
                  ("MatchRefreshCount", c_ubyte),    #µ±Ç°ÒÑË¢ÐÂÆ¥ÅäÁбí´ÎÊý£¬Ã¿´ÎÌôÕ½ºó»áÖØÖÃ
                  ("ItemAddBattleCountToday", c_ubyte),    #½ñÈÕÒÑʹÓÃÎïÆ·Ôö¼ÓµÄÌôÕ½´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xC3
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xC3
        self.IsReset = 0
        self.Score = 0
        self.BattleCountToday = 0
        self.MatchRefreshCount = 0
        self.ItemAddBattleCountToday = 0
        return

    def GetLength(self):
        return sizeof(tagMCArenaPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C3 ¾º¼¼³¡Íæ¼ÒÐÅÏ¢ //tagMCArenaPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                IsReset:%d,
                                Score:%d,
                                BattleCountToday:%d,
                                MatchRefreshCount:%d,
                                ItemAddBattleCountToday:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsReset,
                                self.Score,
                                self.BattleCountToday,
                                self.MatchRefreshCount,
                                self.ItemAddBattleCountToday
                                )
        return DumpString


m_NAtagMCArenaPlayerInfo=tagMCArenaPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCArenaPlayerInfo.Cmd,m_NAtagMCArenaPlayerInfo.SubCmd))] = m_NAtagMCArenaPlayerInfo


#------------------------------------------------------
# A3 0F ֪ͨÍæ¼ÒÐüÉÍÈÎÎñÐÅÏ¢ #tagMCArrestTaskInfo

class  tagMCArrestTaskInfo(Structure):
    Head = tagHead()
    TaskStar = 0    #(BYTE TaskStar)//¿É½ÓÈÎÎñÐǼ¶
    CompleteCnt = 0    #(BYTE CompleteCnt)//µ±ÈÕÒÑÍê³É´ÎÊý
    AwardRecord = 0    #(DWORD AwardRecord)//»ý·Ö½±ÀøÁìÈ¡¼Ç¼
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    TaskDataList = list()    #(vector<DWORD> TaskDataList)//ÈÎÎñÊý¾ÝÁбí, size = Count
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x0F
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TaskStar,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CompleteCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TaskDataList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x0F
        self.TaskStar = 0
        self.CompleteCnt = 0
        self.AwardRecord = 0
        self.Count = 0
        self.TaskDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TaskStar)
        data = CommFunc.WriteBYTE(data, self.CompleteCnt)
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.TaskDataList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TaskStar:%d,
                                CompleteCnt:%d,
                                AwardRecord:%d,
                                Count:%d,
                                TaskDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TaskStar,
                                self.CompleteCnt,
                                self.AwardRecord,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCArrestTaskInfo=tagMCArrestTaskInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCArrestTaskInfo.Head.Cmd,m_NAtagMCArrestTaskInfo.Head.SubCmd))] = m_NAtagMCArrestTaskInfo


#------------------------------------------------------
# A3 39 Íæ¼ÒÊôÐÔ¹ûʵÒÑʹÓøöÊýÐÅÏ¢#tagMCAttrFruitEatCntList

class  tagMCAttrFruitEatCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    #¹ûʵÎïÆ·ID
                  ("EatCnt", c_ushort),    #ÒÑʹÓøöÊý
                  ("ItemAddCnt", c_int),    #Ôö·ùµ¤Ôö¼ÓÉÏÏÞ
                  ("ItemBreakCnt", 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.ItemID = 0
        self.EatCnt = 0
        self.ItemAddCnt = 0
        self.ItemBreakCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCAttrFruitEatCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 39 Íæ¼ÒÊôÐÔ¹ûʵÒÑʹÓøöÊýÐÅÏ¢//tagMCAttrFruitEatCntList:
                                ItemID:%d,
                                EatCnt:%d,
                                ItemAddCnt:%d,
                                ItemBreakCnt:%d
                                '''\
                                %(
                                self.ItemID,
                                self.EatCnt,
                                self.ItemAddCnt,
                                self.ItemBreakCnt
                                )
        return DumpString


class  tagMCAttrFruitEatCntList(Structure):
    Head = tagHead()
    count = 0    #(BYTE count)//ÐÅÏ¢¸öÊý
    EatCntList = list()    #(vector<tagMCAttrFruitEatCnt> EatCntList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x39
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.count):
            temEatCntList = tagMCAttrFruitEatCnt()
            _pos = temEatCntList.ReadData(_lpData, _pos)
            self.EatCntList.append(temEatCntList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x39
        self.count = 0
        self.EatCntList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.count):
            length += self.EatCntList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.count)
        for i in range(self.count):
            data = CommFunc.WriteString(data, self.EatCntList[i].GetLength(), self.EatCntList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                count:%d,
                                EatCntList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.count,
                                "..."
                                )
        return DumpString


m_NAtagMCAttrFruitEatCntList=tagMCAttrFruitEatCntList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAttrFruitEatCntList.Head.Cmd,m_NAtagMCAttrFruitEatCntList.Head.SubCmd))] = m_NAtagMCAttrFruitEatCntList


#------------------------------------------------------
# A3 24 ֪ͨ°óÓñתÅ̽á¹û #tagMCBindJadeWheelResult

class  tagMCBindJadeWheelResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Index", c_ubyte),    # ¸ñ×Ó
                  ("Cnt", c_ubyte),    #½ñÈÕÒÑת´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x24
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x24
        self.Index = 0
        self.Cnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCBindJadeWheelResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 24 ֪ͨ°óÓñתÅ̽á¹û //tagMCBindJadeWheelResult:
                                Cmd:%s,
                                SubCmd:%s,
                                Index:%d,
                                Cnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Index,
                                self.Cnt
                                )
        return DumpString


m_NAtagMCBindJadeWheelResult=tagMCBindJadeWheelResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBindJadeWheelResult.Cmd,m_NAtagMCBindJadeWheelResult.SubCmd))] = m_NAtagMCBindJadeWheelResult


#------------------------------------------------------
#A3 B7 µ±ÈÕÀۼƹ¥»÷boss´ÎÊý #tagMCBOSSAttactCnt

class  tagMCBossCntInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("BossType", c_ubyte),    #±àºÅÀàÐÍ0-ÊÀ½çboss 1-bossÖ®¼Ò
                  ("KillCnt", c_int),    #»÷ɱ´ÎÊý
                  ("ItemAddCnt", c_int),    #ÎïÆ·Ôö¼Ó´ÎÊý
                  ("BuyCnt", c_ubyte),    #¹ºÂò´ÎÊý
                  ("KillCntTotal", 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.BossType = 0
        self.KillCnt = 0
        self.ItemAddCnt = 0
        self.BuyCnt = 0
        self.KillCntTotal = 0
        return

    def GetLength(self):
        return sizeof(tagMCBossCntInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 B7 µ±ÈÕÀۼƹ¥»÷boss´ÎÊý //tagMCBOSSAttactCnt:
                                BossType:%d,
                                KillCnt:%d,
                                ItemAddCnt:%d,
                                BuyCnt:%d,
                                KillCntTotal:%d
                                '''\
                                %(
                                self.BossType,
                                self.KillCnt,
                                self.ItemAddCnt,
                                self.BuyCnt,
                                self.KillCntTotal
                                )
        return DumpString


class  tagMCBOSSAttactCnt(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)
    KillCntInfoList = list()    #(vector<tagMCBossCntInfo> KillCntInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB7
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temKillCntInfoList = tagMCBossCntInfo()
            _pos = temKillCntInfoList.ReadData(_lpData, _pos)
            self.KillCntInfoList.append(temKillCntInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB7
        self.Cnt = 0
        self.KillCntInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.KillCntInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.KillCntInfoList[i].GetLength(), self.KillCntInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                KillCntInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCBOSSAttactCnt=tagMCBOSSAttactCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBOSSAttactCnt.Head.Cmd,m_NAtagMCBOSSAttactCnt.Head.SubCmd))] = m_NAtagMCBOSSAttactCnt


#------------------------------------------------------
# A3 BD ֪ͨÍæ¼Ò¹ºÂò¸±±¾½øÈë´ÎÊý #tagMCBuyEnterInfo

class  tagMCBuyInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FBID", c_int),    # ¸±±¾ID
                  ("BuyCount", c_ubyte),    # ÒѹºÂò´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.FBID = 0
        self.BuyCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCBuyInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 BD ֪ͨÍæ¼Ò¹ºÂò¸±±¾½øÈë´ÎÊý //tagMCBuyEnterInfo:
                                FBID:%d,
                                BuyCount:%d
                                '''\
                                %(
                                self.FBID,
                                self.BuyCount
                                )
        return DumpString


class  tagMCBuyEnterInfo(Structure):
    Head = tagHead()
    FBCount = 0    #(BYTE FBCount)// ¸±±¾¸öÊý
    FBInfo = list()    #(vector<tagMCBuyInfo> FBInfo)// ¸±±¾ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBD
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FBCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FBCount):
            temFBInfo = tagMCBuyInfo()
            _pos = temFBInfo.ReadData(_lpData, _pos)
            self.FBInfo.append(temFBInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBD
        self.FBCount = 0
        self.FBInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.FBCount):
            length += self.FBInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FBCount)
        for i in range(self.FBCount):
            data = CommFunc.WriteString(data, self.FBInfo[i].GetLength(), self.FBInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FBCount:%d,
                                FBInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FBCount,
                                "..."
                                )
        return DumpString


m_NAtagMCBuyEnterInfo=tagMCBuyEnterInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBuyEnterInfo.Head.Cmd,m_NAtagMCBuyEnterInfo.Head.SubCmd))] = m_NAtagMCBuyEnterInfo


#------------------------------------------------------
# A3 B0 Íæ¼Ò¹ºÂòħ»êÍ­Ç®¾­Ñé¶îÍâ½±ÀøÐÅÏ¢ #tagMCBuySomethingReward

class  tagMCBuySomethingReward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("BuyType", c_ubyte),    #¹ºÂòÀàÐÍ(0-½ð±Ò, 1-ħ»ê, 2-¾­Ñé)
                  ("OnceNum", c_int),    # µ¥±¶ÊýÖµ
                  ("OnceNumPoint", c_int),    # µ¥±¶ÊýÖµµã
                  ("MulNum", c_ubyte),    #±©»÷±¶Öµ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xB0
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xB0
        self.BuyType = 0
        self.OnceNum = 0
        self.OnceNumPoint = 0
        self.MulNum = 0
        return

    def GetLength(self):
        return sizeof(tagMCBuySomethingReward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 B0 Íæ¼Ò¹ºÂòħ»êÍ­Ç®¾­Ñé¶îÍâ½±ÀøÐÅÏ¢ //tagMCBuySomethingReward:
                                Cmd:%s,
                                SubCmd:%s,
                                BuyType:%d,
                                OnceNum:%d,
                                OnceNumPoint:%d,
                                MulNum:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.BuyType,
                                self.OnceNum,
                                self.OnceNumPoint,
                                self.MulNum
                                )
        return DumpString


m_NAtagMCBuySomethingReward=tagMCBuySomethingReward()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBuySomethingReward.Cmd,m_NAtagMCBuySomethingReward.SubCmd))] = m_NAtagMCBuySomethingReward


#------------------------------------------------------
#A3 23 ²É¼¯»ñµÃÎïÆ·ÐÅÏ¢ # tagMCCollectionItemInfo

class  tagMCCollectionItem(Structure):
    Head = tagHead()
    ItemType = 0    #(BYTE ItemType)//ÎïÆ·ÀàÐÍ£¬0-ÆÕͨÎïÆ·£¬1-¶¨ÖƱíÎïÆ·
    ItemID = 0    #(DWORD ItemID)//µ±ÎïÆ·ÀàÐÍΪÆÕͨÎïƷʱ±íʾÎïÆ·id£¬Îª¶¨ÖÆÎïƷʱ±íʾ¶¨ÖÆÎïÆ·±íÀïµÄItemIndex
    ItemCnt = 0    #(DWORD ItemCnt)//»ñµÃ¸öÊý
    IsBind = 0    #(BYTE IsBind)//ÊÇ·ñ°ó¶¨
    ItemInfoLen = 0    #(BYTE ItemInfoLen)
    ItemInfo = ""    #(String ItemInfo)//×°±¸¸½¼ÓÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x23
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsBind,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemInfoLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x23
        self.ItemType = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        self.ItemInfoLen = 0
        self.ItemInfo = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 4
        length += 1
        length += 1
        length += len(self.ItemInfo)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ItemType)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteDWORD(data, self.ItemCnt)
        data = CommFunc.WriteBYTE(data, self.IsBind)
        data = CommFunc.WriteBYTE(data, self.ItemInfoLen)
        data = CommFunc.WriteString(data, self.ItemInfoLen, self.ItemInfo)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemType:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d,
                                ItemInfoLen:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemType,
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind,
                                self.ItemInfoLen,
                                self.ItemInfo
                                )
        return DumpString


class  tagMCCollectionItemInfo(Structure):
    Head = tagHead()
    NPCID = 0    #(DWORD NPCID)// ²É¼¯¶ÔÏóNPCID
    Exp = 0    #(DWORD Exp)// »ñµÃµÄ¾­Ñé
    SilverMoney = 0    #(DWORD SilverMoney)// »ñµÃµÄ½ð±Ò
    ZhenQi = 0    #(DWORD ZhenQi)// »ñµÃµÄÕæÆø
    CollItemIDCnt = 0    #(BYTE CollItemIDCnt)// »ñµÃµÄÎïÆ·ID¸öÊý
    CollItemList = list()    #(vector<tagMCCollectionItem> CollItemList)//»ñµÃµÄÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x23
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Exp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SilverMoney,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ZhenQi,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CollItemIDCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CollItemIDCnt):
            temCollItemList = tagMCCollectionItem()
            _pos = temCollItemList.ReadData(_lpData, _pos)
            self.CollItemList.append(temCollItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x23
        self.NPCID = 0
        self.Exp = 0
        self.SilverMoney = 0
        self.ZhenQi = 0
        self.CollItemIDCnt = 0
        self.CollItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        for i in range(self.CollItemIDCnt):
            length += self.CollItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteDWORD(data, self.Exp)
        data = CommFunc.WriteDWORD(data, self.SilverMoney)
        data = CommFunc.WriteDWORD(data, self.ZhenQi)
        data = CommFunc.WriteBYTE(data, self.CollItemIDCnt)
        for i in range(self.CollItemIDCnt):
            data = CommFunc.WriteString(data, self.CollItemList[i].GetLength(), self.CollItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                NPCID:%d,
                                Exp:%d,
                                SilverMoney:%d,
                                ZhenQi:%d,
                                CollItemIDCnt:%d,
                                CollItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.NPCID,
                                self.Exp,
                                self.SilverMoney,
                                self.ZhenQi,
                                self.CollItemIDCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCCollectionItemInfo=tagMCCollectionItemInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCollectionItemInfo.Head.Cmd,m_NAtagMCCollectionItemInfo.Head.SubCmd))] = m_NAtagMCCollectionItemInfo


#------------------------------------------------------
# A3 CC ×Ô¶¨Òå½±ÀøÐÅÏ¢ #tagMCCustomAwardInfo

class  tagMCCustomAwardState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("KeyNum", c_ushort),    # ½±Àø¼Ç¼key±àºÅ£¬0~255£¬Ã¿¸ökey´æ31¸öID¼Ç¼  0-30Ϊ±àºÅ0, 31-61Ϊ±àºÅ1..
                  ("CanGetState", c_int),    # ÊÇ·ñ¿ÉÁìÈ¡£»°´Î»¼Ç¼ÊÇ·ñ¿ÉÁìÈ¡
                  ("GetState", 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.KeyNum = 0
        self.CanGetState = 0
        self.GetState = 0
        return

    def GetLength(self):
        return sizeof(tagMCCustomAwardState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 CC ×Ô¶¨Òå½±ÀøÐÅÏ¢ //tagMCCustomAwardInfo:
                                KeyNum:%d,
                                CanGetState:%d,
                                GetState:%d
                                '''\
                                %(
                                self.KeyNum,
                                self.CanGetState,
                                self.GetState
                                )
        return DumpString


class  tagMCCustomAwardInfo(Structure):
    Head = tagHead()
    RecordStateCnt = 0    #(WORD RecordStateCnt)// ¼Ç¼¸öÊý
    RecordStateList = list()    #(vector<tagMCCustomAwardState> RecordStateList)// ¼Ç¼Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCC
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RecordStateCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RecordStateCnt):
            temRecordStateList = tagMCCustomAwardState()
            _pos = temRecordStateList.ReadData(_lpData, _pos)
            self.RecordStateList.append(temRecordStateList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCC
        self.RecordStateCnt = 0
        self.RecordStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.RecordStateCnt):
            length += self.RecordStateList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RecordStateCnt)
        for i in range(self.RecordStateCnt):
            data = CommFunc.WriteString(data, self.RecordStateList[i].GetLength(), self.RecordStateList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RecordStateCnt:%d,
                                RecordStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RecordStateCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCCustomAwardInfo=tagMCCustomAwardInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCustomAwardInfo.Head.Cmd,m_NAtagMCCustomAwardInfo.Head.SubCmd))] = m_NAtagMCCustomAwardInfo


#------------------------------------------------------
# A3 15 ÈÕ³£»î¶¯´ÎÊý֪ͨ #tagMCDailyActionCnt

class  tagMCDailyActionInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ActionID", c_int),    # ID
                  ("DayFinishCnt", c_ushort),    # ½ñÈÕÒÑÍê³É´ÎÊý
                  ("DayBuyTimes", c_ubyte),    # ½ñÈÕ¹ºÂò´ÎÊý
                  ("DayItemTimes", c_ubyte),    # ½ñÈÕÎïÆ·Ôö¼Ó´ÎÊý
                  ("WeekFinishCnt", c_int),    # ±¾ÖÜÒÑÍê³É´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ActionID = 0
        self.DayFinishCnt = 0
        self.DayBuyTimes = 0
        self.DayItemTimes = 0
        self.WeekFinishCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCDailyActionInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 15 ÈÕ³£»î¶¯´ÎÊý֪ͨ //tagMCDailyActionCnt:
                                ActionID:%d,
                                DayFinishCnt:%d,
                                DayBuyTimes:%d,
                                DayItemTimes:%d,
                                WeekFinishCnt:%d
                                '''\
                                %(
                                self.ActionID,
                                self.DayFinishCnt,
                                self.DayBuyTimes,
                                self.DayItemTimes,
                                self.WeekFinishCnt
                                )
        return DumpString


class  tagMCDailyActionCnt(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ¸öÊý
    ActionInfo = list()    #(vector<tagMCDailyActionInfo> ActionInfo)// »î¶¯ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temActionInfo = tagMCDailyActionInfo()
            _pos = temActionInfo.ReadData(_lpData, _pos)
            self.ActionInfo.append(temActionInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x15
        self.Count = 0
        self.ActionInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.ActionInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ActionInfo[i].GetLength(), self.ActionInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ActionInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCDailyActionCnt=tagMCDailyActionCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDailyActionCnt.Head.Cmd,m_NAtagMCDailyActionCnt.Head.SubCmd))] = m_NAtagMCDailyActionCnt


#------------------------------------------------------
#A3 33 Íæ¼ÒÿÈÕ»îÔ¾¶È #tagMCDailyActivityInfoList

class  tagMCDailyActivityInfoList(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CurValue", c_int),    # µ±Ç°×Ü»îÔ¾¶È
                  ("RealmPoint", c_int),    # ¿ÉÁìÈ¡ÐÞÐеã
                  ("StageIndex", c_ubyte),    # µ±Ç°½×¶ÎË÷Òý
                  ("AwardRecord", c_int),    # Áì½±¼Ç¼ °´Î»´æ´¢
                  ("ExtraPoint", c_int),    # ¶à±¶»î¶¯»ñµÃµÄ¶îÍâÐÞÐеã
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x33
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x33
        self.CurValue = 0
        self.RealmPoint = 0
        self.StageIndex = 0
        self.AwardRecord = 0
        self.ExtraPoint = 0
        return

    def GetLength(self):
        return sizeof(tagMCDailyActivityInfoList)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 33 Íæ¼ÒÿÈÕ»îÔ¾¶È //tagMCDailyActivityInfoList:
                                Cmd:%s,
                                SubCmd:%s,
                                CurValue:%d,
                                RealmPoint:%d,
                                StageIndex:%d,
                                AwardRecord:%d,
                                ExtraPoint:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CurValue,
                                self.RealmPoint,
                                self.StageIndex,
                                self.AwardRecord,
                                self.ExtraPoint
                                )
        return DumpString


m_NAtagMCDailyActivityInfoList=tagMCDailyActivityInfoList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDailyActivityInfoList.Cmd,m_NAtagMCDailyActivityInfoList.SubCmd))] = m_NAtagMCDailyActivityInfoList


#------------------------------------------------------
#A3 0D Íæ¼ÒÇ©µ½ÐÅÏ¢¼Ç¼ # tagMCDaySignInfo

class  tagMCDaySignInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DaySignCount", c_ubyte),    #ÒѾ­Ç©µ½ÌìÊý
                  ("ReplenishSignCount", c_ubyte),    # ¿ÉÒÔ²¹Ç©ÌìÊý
                  ("IsSign", c_ubyte),    #µ±ÌìÊÇ·ñÒѾ­Ç©µ½,·¢ËÍ0ºÍ1
                  ("IsFrist", c_ubyte),    #ÊÇ·ñÊǵÚÒ»¸öÔÂ
                  ("TotalSignCount", c_ushort),    #ÀÛ¼Æ×ÜÇ©µ½ÌìÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x0D
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x0D
        self.DaySignCount = 0
        self.ReplenishSignCount = 0
        self.IsSign = 0
        self.IsFrist = 0
        self.TotalSignCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCDaySignInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 0D Íæ¼ÒÇ©µ½ÐÅÏ¢¼Ç¼ // tagMCDaySignInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                DaySignCount:%d,
                                ReplenishSignCount:%d,
                                IsSign:%d,
                                IsFrist:%d,
                                TotalSignCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DaySignCount,
                                self.ReplenishSignCount,
                                self.IsSign,
                                self.IsFrist,
                                self.TotalSignCount
                                )
        return DumpString


m_NAtagMCDaySignInfo=tagMCDaySignInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDaySignInfo.Cmd,m_NAtagMCDaySignInfo.SubCmd))] = m_NAtagMCDaySignInfo


#------------------------------------------------------
# A3 C1 ÉñÊÞÖúս״̬ˢР#tagMCDogzHelpbattleState

class  tagMCDogzHelpbattleState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DogzID", c_ubyte),    # ÉñÊÞID
                  ("BatteState", c_ubyte),    #ÊÇ·ñÒÑÖúÕ½, 0·ñ1ÊÇ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xC1
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xC1
        self.DogzID = 0
        self.BatteState = 0
        return

    def GetLength(self):
        return sizeof(tagMCDogzHelpbattleState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C1 ÉñÊÞÖúս״̬ˢР//tagMCDogzHelpbattleState:
                                Cmd:%s,
                                SubCmd:%s,
                                DogzID:%d,
                                BatteState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DogzID,
                                self.BatteState
                                )
        return DumpString


m_NAtagMCDogzHelpbattleState=tagMCDogzHelpbattleState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDogzHelpbattleState.Cmd,m_NAtagMCDogzHelpbattleState.SubCmd))] = m_NAtagMCDogzHelpbattleState


#------------------------------------------------------
# A3 C0 ÉñÊÞÐÅÏ¢ #tagMCDogzInfo

class  tagMCDogzInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("BuyHelpbattleCount", c_ubyte),    #¶îÍ⹺ÂòµÄÖúÕ½Êý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xC0
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xC0
        self.BuyHelpbattleCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCDogzInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C0 ÉñÊÞÐÅÏ¢ //tagMCDogzInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                BuyHelpbattleCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.BuyHelpbattleCount
                                )
        return DumpString


m_NAtagMCDogzInfo=tagMCDogzInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDogzInfo.Cmd,m_NAtagMCDogzInfo.SubCmd))] = m_NAtagMCDogzInfo


#------------------------------------------------------
# A3 1C ֪ͨװ±¸·Ö½âÐÅÏ¢ #tagMCEquipDecomposeInfo

class  tagMCEquipDecomposeInfo(Structure):
    Head = tagHead()
    LV = 0    #(WORD LV)// µÈ¼¶
    Exp = 0    #(DWORD Exp)// Éý¼¶¾­Ñé
    Seting = 0    #(DWORD Seting)// ²Ù×÷Êý¾Ý¼Ç¼
    DecomposeCnt = 0    #(BYTE DecomposeCnt)// ·Ö½â¼þÊý½ø¶È
    GetItemLen = 0    #(WORD GetItemLen)
    GetItemData = ""    #(String GetItemData)//  »ñµÃÎïÆ·ÐÅÏ¢ [[itemID,itemCount,isBind], [»òitemID,itemCount,isBind,isAppoint], {»òÎïÆ·ÐÅÏ¢×Öµä}, ...] 
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1C
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Exp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Seting,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DecomposeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GetItemLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GetItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.GetItemLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1C
        self.LV = 0
        self.Exp = 0
        self.Seting = 0
        self.DecomposeCnt = 0
        self.GetItemLen = 0
        self.GetItemData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 4
        length += 4
        length += 1
        length += 2
        length += len(self.GetItemData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.Exp)
        data = CommFunc.WriteDWORD(data, self.Seting)
        data = CommFunc.WriteBYTE(data, self.DecomposeCnt)
        data = CommFunc.WriteWORD(data, self.GetItemLen)
        data = CommFunc.WriteString(data, self.GetItemLen, self.GetItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                LV:%d,
                                Exp:%d,
                                Seting:%d,
                                DecomposeCnt:%d,
                                GetItemLen:%d,
                                GetItemData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.LV,
                                self.Exp,
                                self.Seting,
                                self.DecomposeCnt,
                                self.GetItemLen,
                                self.GetItemData
                                )
        return DumpString


m_NAtagMCEquipDecomposeInfo=tagMCEquipDecomposeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipDecomposeInfo.Head.Cmd,m_NAtagMCEquipDecomposeInfo.Head.SubCmd))] = m_NAtagMCEquipDecomposeInfo


#------------------------------------------------------
# A3 C4 ×°±¸Éñ×°²ð½â½á¹û #tagMCEquipDecomposeRet

class  tagMCEquipDecomposeRet(Structure):
    Head = tagHead()
    DecomposeEquipIDCount = 0    #(BYTE DecomposeEquipIDCount)// ÒÑ·Ö½âµÄ×°±¸¸öÊý
    DecomposeEquipIDList = list()    #(vector<DWORD> DecomposeEquipIDList)// ÒÑ·Ö½âµÄÉñ×°×°±¸IDÁбí
    GetItemLen = 0    #(WORD GetItemLen)
    GetItemData = ""    #(String GetItemData)//  »ñµÃÎïÆ·ÐÅÏ¢ [[itemID,itemCount,isBind], [»òitemID,itemCount,isBind,isAppoint], {»òÎïÆ·ÐÅÏ¢×Öµä}, ...] 
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC4
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.DecomposeEquipIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DecomposeEquipIDCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.DecomposeEquipIDList.append(value)
        self.GetItemLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GetItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.GetItemLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC4
        self.DecomposeEquipIDCount = 0
        self.DecomposeEquipIDList = list()
        self.GetItemLen = 0
        self.GetItemData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.DecomposeEquipIDCount
        length += 2
        length += len(self.GetItemData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.DecomposeEquipIDCount)
        for i in range(self.DecomposeEquipIDCount):
            data = CommFunc.WriteDWORD(data, self.DecomposeEquipIDList[i])
        data = CommFunc.WriteWORD(data, self.GetItemLen)
        data = CommFunc.WriteString(data, self.GetItemLen, self.GetItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                DecomposeEquipIDCount:%d,
                                DecomposeEquipIDList:%s,
                                GetItemLen:%d,
                                GetItemData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.DecomposeEquipIDCount,
                                "...",
                                self.GetItemLen,
                                self.GetItemData
                                )
        return DumpString


m_NAtagMCEquipDecomposeRet=tagMCEquipDecomposeRet()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipDecomposeRet.Head.Cmd,m_NAtagMCEquipDecomposeRet.Head.SubCmd))] = m_NAtagMCEquipDecomposeRet


#------------------------------------------------------
# A3 B1 ×°±¸²¿Î»ÐÇÊýÐÅÏ¢ #tagMCEquipPartStarInfo

class  tagMCEquipPartStar(Structure):
    _pack_ = 1
    _fields_ = [
                  ("EquipPackIndex", c_ushort),    
                  ("Star", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.EquipPackIndex = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCEquipPartStar)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 B1 ×°±¸²¿Î»ÐÇÊýÐÅÏ¢ //tagMCEquipPartStarInfo:
                                EquipPackIndex:%d,
                                Star:%d
                                '''\
                                %(
                                self.EquipPackIndex,
                                self.Star
                                )
        return DumpString


class  tagMCEquipPartStarInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagMCEquipPartStar> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB1
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCEquipPartStar()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB1
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCEquipPartStarInfo=tagMCEquipPartStarInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipPartStarInfo.Head.Cmd,m_NAtagMCEquipPartStarInfo.Head.SubCmd))] = m_NAtagMCEquipPartStarInfo


#------------------------------------------------------
# A3 B2 ×°±¸²¿Î»ÐǼ¶Ì××°¼¤»îÐÅÏ¢ #tagMCEquipPartSuiteActivateInfo

class  tagMCEquipPartSuiteActivateInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    SuiteActivateStateInfo = list()    #(vector<DWORD> SuiteActivateStateInfo)//¼¤»î״ֵ̬ÁÐ±í£¬Ã¿¸öÊý°´Î»´æ31¸ö¼¤»îË÷Òý£¬Ã¿¸öλ´ú±í¶ÔÓ¦µÄ¼¤»îË÷ÒýÊÇ·ñÒѼ¤»î
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB2
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.SuiteActivateStateInfo.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB2
        self.Count = 0
        self.SuiteActivateStateInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.SuiteActivateStateInfo[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                SuiteActivateStateInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCEquipPartSuiteActivateInfo=tagMCEquipPartSuiteActivateInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipPartSuiteActivateInfo.Head.Cmd,m_NAtagMCEquipPartSuiteActivateInfo.Head.SubCmd))] = m_NAtagMCEquipPartSuiteActivateInfo


#------------------------------------------------------
# A3 BB ×°±¸Î»Ï´Á·ÊôÐÔÐÅÏ¢ #tagMCEquipPartXLAttrInfo

class  tagMCEquipPartXLAttrValue(Structure):
    _pack_ = 1
    _fields_ = [
                  ("XLAttrValue", c_int),    # µ±Ç°ÊôÐÔÖµ
                  ("XLAttrChange", 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.XLAttrValue = 0
        self.XLAttrChange = 0
        return

    def GetLength(self):
        return sizeof(tagMCEquipPartXLAttrValue)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 BB ×°±¸Î»Ï´Á·ÊôÐÔÐÅÏ¢ //tagMCEquipPartXLAttrInfo:
                                XLAttrValue:%d,
                                XLAttrChange:%d
                                '''\
                                %(
                                self.XLAttrValue,
                                self.XLAttrChange
                                )
        return DumpString


class  tagMCEquipPartXLAttr(Structure):
    EquipPlace = 0    #(BYTE EquipPlace)// ×°±¸Î»	
    XLAttrLV = 0    #(BYTE XLAttrLV)// Ï´Á·µÈ¼¶
    XLAttrCnt = 0    #(BYTE XLAttrCnt)// ÊôÐÔÌõÊý
    XLAttrList = list()    #(vector<tagMCEquipPartXLAttrValue> XLAttrList)// ÊôÐÔÁбí,Ë÷Òý0µÄ´ú±íÊôÐÔ1,ÒÀ´ÎµÝÔö
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.EquipPlace,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.XLAttrLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.XLAttrCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.XLAttrCnt):
            temXLAttrList = tagMCEquipPartXLAttrValue()
            _pos = temXLAttrList.ReadData(_lpData, _pos)
            self.XLAttrList.append(temXLAttrList)
        return _pos

    def Clear(self):
        self.EquipPlace = 0
        self.XLAttrLV = 0
        self.XLAttrCnt = 0
        self.XLAttrList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        for i in range(self.XLAttrCnt):
            length += self.XLAttrList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.EquipPlace)
        data = CommFunc.WriteBYTE(data, self.XLAttrLV)
        data = CommFunc.WriteBYTE(data, self.XLAttrCnt)
        for i in range(self.XLAttrCnt):
            data = CommFunc.WriteString(data, self.XLAttrList[i].GetLength(), self.XLAttrList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                EquipPlace:%d,
                                XLAttrLV:%d,
                                XLAttrCnt:%d,
                                XLAttrList:%s
                                '''\
                                %(
                                self.EquipPlace,
                                self.XLAttrLV,
                                self.XLAttrCnt,
                                "..."
                                )
        return DumpString


class  tagMCEquipPartXLAttrInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagMCEquipPartXLAttr> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBB
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCEquipPartXLAttr()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBB
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCEquipPartXLAttrInfo=tagMCEquipPartXLAttrInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipPartXLAttrInfo.Head.Cmd,m_NAtagMCEquipPartXLAttrInfo.Head.SubCmd))] = m_NAtagMCEquipPartXLAttrInfo


#------------------------------------------------------
# A3 07 çÎç¿ÆæÓöÐÅÏ¢ #tagMCFairyAdventuresInfo

class  tagMCFairyAdventuresData(Structure):
    _pack_ = 1
    _fields_ = [
                  ("EventID", c_ubyte),    
                  ("Gear", c_ubyte),    #µÚ¼¸µµ
                  ("Condition", 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.EventID = 0
        self.Gear = 0
        self.Condition = 0
        return

    def GetLength(self):
        return sizeof(tagMCFairyAdventuresData)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 07 çÎç¿ÆæÓöÐÅÏ¢ //tagMCFairyAdventuresInfo:
                                EventID:%d,
                                Gear:%d,
                                Condition:%d
                                '''\
                                %(
                                self.EventID,
                                self.Gear,
                                self.Condition
                                )
        return DumpString


class  tagMCFairyAdventuresInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)
    InfoList = list()    #(vector<tagMCFairyAdventuresData> InfoList)// ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x07
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCFairyAdventuresData()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x07
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFairyAdventuresInfo=tagMCFairyAdventuresInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFairyAdventuresInfo.Head.Cmd,m_NAtagMCFairyAdventuresInfo.Head.SubCmd))] = m_NAtagMCFairyAdventuresInfo


#------------------------------------------------------
# A3 06 çÎç¿ÏÉÓòÐÅÏ¢ #tagMCFairyDomainInfo

class  tagMCFairyDomainEvent(Structure):
    _pack_ = 1
    _fields_ = [
                  ("EventID", c_ushort),    #ʼþID
                  ("EventState", c_ubyte),    #ʼþ״̬ 1-¿É°Ý·Ã 2-°Ý·ÃÖÐ 3-ÒÑ°Ý·Ã
                  ]

    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.EventID = 0
        self.EventState = 0
        return

    def GetLength(self):
        return sizeof(tagMCFairyDomainEvent)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 06 çÎç¿ÏÉÓòÐÅÏ¢ //tagMCFairyDomainInfo:
                                EventID:%d,
                                EventState:%d
                                '''\
                                %(
                                self.EventID,
                                self.EventState
                                )
        return DumpString


class  tagMCFairyDomainInfo(Structure):
    Head = tagHead()
    IsAll = 0    #(BYTE IsAll)//ÊÇ·ñÈ«²¿
    State = 0    #(BYTE State)//0-δѰ·Ã 1-Ñ°·ÃÖÐ 2-ÈÎÎñ±ê¼Ç¿ÉÑ°·Ã
    VisitCnt = 0    #(DWORD VisitCnt)//Ñ°·Ã´ÎÊý
    Energy = 0    #(WORD Energy)//ÌåÁ¦
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagMCFairyDomainEvent> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.IsAll,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.State,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.VisitCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Energy,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCFairyDomainEvent()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x06
        self.IsAll = 0
        self.State = 0
        self.VisitCnt = 0
        self.Energy = 0
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4
        length += 2
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsAll)
        data = CommFunc.WriteBYTE(data, self.State)
        data = CommFunc.WriteDWORD(data, self.VisitCnt)
        data = CommFunc.WriteWORD(data, self.Energy)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                IsAll:%d,
                                State:%d,
                                VisitCnt:%d,
                                Energy:%d,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.IsAll,
                                self.State,
                                self.VisitCnt,
                                self.Energy,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFairyDomainInfo=tagMCFairyDomainInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFairyDomainInfo.Head.Cmd,m_NAtagMCFairyDomainInfo.Head.SubCmd))] = m_NAtagMCFairyDomainInfo


#------------------------------------------------------
# A3 16 ÏÉÃË»îÔ¾ÐÅϢ֪ͨ #tagMCFamilyActivityInfo

class  tagMCFamilyActionCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ActionID", c_ubyte),    # ID
                  ("FinishCnt", c_ushort),    # ÒÑÍê³É´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ActionID = 0
        self.FinishCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyActionCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 16 ÏÉÃË»îÔ¾ÐÅϢ֪ͨ //tagMCFamilyActivityInfo:
                                ActionID:%d,
                                FinishCnt:%d
                                '''\
                                %(
                                self.ActionID,
                                self.FinishCnt
                                )
        return DumpString


class  tagMCFamilyActivityInfo(Structure):
    Head = tagHead()
    AwardRecord = 0    #(DWORD AwardRecord)// Áì½±Çé¿ö¼Ç¼
    Count = 0    #(BYTE Count)// ¸öÊý
    InfoList = list()    #(vector<tagMCFamilyActionCnt> InfoList)// »î¶¯ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x16
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCFamilyActionCnt()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x16
        self.AwardRecord = 0
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AwardRecord:%d,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AwardRecord,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFamilyActivityInfo=tagMCFamilyActivityInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyActivityInfo.Head.Cmd,m_NAtagMCFamilyActivityInfo.Head.SubCmd))] = m_NAtagMCFamilyActivityInfo


#------------------------------------------------------
# A3 54 ·¨Æ÷ÐÅÏ¢ #tagMCFaQiInfo

class  tagMCFaQiInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LV", c_ubyte),    #µÈ½×
                  ("EatItemCount", c_int),    #µ±Ç°½×ÒѳԵ¤¸öÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x54
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x54
        self.LV = 0
        self.EatItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCFaQiInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 54 ·¨Æ÷ÐÅÏ¢ //tagMCFaQiInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                LV:%d,
                                EatItemCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LV,
                                self.EatItemCount
                                )
        return DumpString


m_NAtagMCFaQiInfo=tagMCFaQiInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFaQiInfo.Cmd,m_NAtagMCFaQiInfo.SubCmd))] = m_NAtagMCFaQiInfo


#------------------------------------------------------
#A3 0A ¸±±¾¹ÄÎèÐÅϢ֪ͨ #tagMCFBEncourageInfo

class  tagMCFBEncourageCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MoneyType", c_ubyte),    # ½ðÇ®ÀàÐÍ
                  ("EncourageCnt", c_ubyte),    # µ±Ç°¹ÄÎè´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.MoneyType = 0
        self.EncourageCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFBEncourageCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 0A ¸±±¾¹ÄÎèÐÅϢ֪ͨ //tagMCFBEncourageInfo:
                                MoneyType:%d,
                                EncourageCnt:%d
                                '''\
                                %(
                                self.MoneyType,
                                self.EncourageCnt
                                )
        return DumpString


class  tagMCFBEncourageInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// 
    InfoList = list()    #(vector<tagMCFBEncourageCnt> InfoList)// ´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x0A
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCFBEncourageCnt()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x0A
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFBEncourageInfo=tagMCFBEncourageInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBEncourageInfo.Head.Cmd,m_NAtagMCFBEncourageInfo.Head.SubCmd))] = m_NAtagMCFBEncourageInfo


#------------------------------------------------------
#A3 04 Íæ¼Òɨµ´ÐÅÏ¢ #tagMCFBWipeOutData

class  tagMCFBData(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FBID", c_int),    #fbId
                  ("LineIndex", c_ubyte),    #¸±±¾Í¨¹Ø³¡´Î
                  ("WipeOutCnt", c_ubyte),    #ɨµ´´ÎÊý
                  ("passGrade", c_ubyte),    #ͨ¹ØÆÀ¼¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.FBID = 0
        self.LineIndex = 0
        self.WipeOutCnt = 0
        self.passGrade = 0
        return

    def GetLength(self):
        return sizeof(tagMCFBData)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 04 Íæ¼Òɨµ´ÐÅÏ¢ //tagMCFBWipeOutData:
                                FBID:%d,
                                LineIndex:%d,
                                WipeOutCnt:%d,
                                passGrade:%d
                                '''\
                                %(
                                self.FBID,
                                self.LineIndex,
                                self.WipeOutCnt,
                                self.passGrade
                                )
        return DumpString


class  tagMCFBWipeOutData(Structure):
    Head = tagHead()
    WipeOutFBID = 0    #(DWORD WipeOutFBID)//µ±Ç°É¨µ´µÄ¸±±¾id
    FBDataCnt = 0    #(BYTE FBDataCnt)//
    FBDataList = list()    #(vector<tagMCFBData> FBDataList)//
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.WipeOutFBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FBDataCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FBDataCnt):
            temFBDataList = tagMCFBData()
            _pos = temFBDataList.ReadData(_lpData, _pos)
            self.FBDataList.append(temFBDataList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x04
        self.WipeOutFBID = 0
        self.FBDataCnt = 0
        self.FBDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.FBDataCnt):
            length += self.FBDataList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.WipeOutFBID)
        data = CommFunc.WriteBYTE(data, self.FBDataCnt)
        for i in range(self.FBDataCnt):
            data = CommFunc.WriteString(data, self.FBDataList[i].GetLength(), self.FBDataList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                WipeOutFBID:%d,
                                FBDataCnt:%d,
                                FBDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.WipeOutFBID,
                                self.FBDataCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFBWipeOutData=tagMCFBWipeOutData()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBWipeOutData.Head.Cmd,m_NAtagMCFBWipeOutData.Head.SubCmd))] = m_NAtagMCFBWipeOutData


#------------------------------------------------------
# A3 18 ¼«Æ·°×ÄÃÐÅÏ¢ #tagMCFreeGoodsInfo

class  tagMCFreeGoods(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ID", c_ubyte),    # Àñ°üID
                  ("BuyState", c_int),    # ¹ºÂò״̬ 0-δ¹ºÂò 1-ÒÑÁì·µ»¹ timeÖµ-¹ºÂòʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ID = 0
        self.BuyState = 0
        return

    def GetLength(self):
        return sizeof(tagMCFreeGoods)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 18 ¼«Æ·°×ÄÃÐÅÏ¢ //tagMCFreeGoodsInfo:
                                ID:%d,
                                BuyState:%d
                                '''\
                                %(
                                self.ID,
                                self.BuyState
                                )
        return DumpString


class  tagMCFreeGoodsInfo(Structure):
    Head = tagHead()
    OpenTime = 0    #(DWORD OpenTime)// »î¶¯¿ªÆôʱ¼ä
    Count = 0    #(BYTE Count)// ¸öÊý
    FreeGoodsList = list()    #(vector<tagMCFreeGoods> FreeGoodsList)// ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x18
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OpenTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temFreeGoodsList = tagMCFreeGoods()
            _pos = temFreeGoodsList.ReadData(_lpData, _pos)
            self.FreeGoodsList.append(temFreeGoodsList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x18
        self.OpenTime = 0
        self.Count = 0
        self.FreeGoodsList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.FreeGoodsList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.OpenTime)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.FreeGoodsList[i].GetLength(), self.FreeGoodsList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OpenTime:%d,
                                Count:%d,
                                FreeGoodsList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OpenTime,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFreeGoodsInfo=tagMCFreeGoodsInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFreeGoodsInfo.Head.Cmd,m_NAtagMCFreeGoodsInfo.Head.SubCmd))] = m_NAtagMCFreeGoodsInfo


#------------------------------------------------------
# A3 22 ¹¦ÄÜNPCÒѲɼ¯´ÎÊý #tagMCFuncNPCCollectionCnt

class  tagMCFuncNPCCollectionCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("FuncType", c_int),    #NPC¹¦ÄÜÀàÐÍ
                  ("CollectionCnt", c_int),    #ÒѲɼ¯´ÎÊý
                  ("BuyCnt", c_ubyte),    # ÒѹºÂò´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x22
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x22
        self.FuncType = 0
        self.CollectionCnt = 0
        self.BuyCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFuncNPCCollectionCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 22 ¹¦ÄÜNPCÒѲɼ¯´ÎÊý //tagMCFuncNPCCollectionCnt:
                                Cmd:%s,
                                SubCmd:%s,
                                FuncType:%d,
                                CollectionCnt:%d,
                                BuyCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.FuncType,
                                self.CollectionCnt,
                                self.BuyCnt
                                )
        return DumpString


m_NAtagMCFuncNPCCollectionCnt=tagMCFuncNPCCollectionCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFuncNPCCollectionCnt.Cmd,m_NAtagMCFuncNPCCollectionCnt.SubCmd))] = m_NAtagMCFuncNPCCollectionCnt


#------------------------------------------------------
#A3 02 ¹¦ÄÜ¿ªÍ¨×´Ì¬ #tagMCFuncOpenStateList

class  tagMCFuncOpenState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FuncID", c_ubyte),    # ¹¦ÄÜID
                  ("State", c_ubyte),    # ÊÇ·ñ¿ªÆô
                  ("AwardState", c_ubyte),    # ÊÇ·ñÒÑÁì½±Àø
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.FuncID = 0
        self.State = 0
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCFuncOpenState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 02 ¹¦ÄÜ¿ªÍ¨×´Ì¬ //tagMCFuncOpenStateList:
                                FuncID:%d,
                                State:%d,
                                AwardState:%d
                                '''\
                                %(
                                self.FuncID,
                                self.State,
                                self.AwardState
                                )
        return DumpString


class  tagMCFuncOpenStateList(Structure):
    Head = tagHead()
    FuncCount = 0    #(BYTE FuncCount)// ¹¦ÄܸöÊý
    FuncStateList = list()    #(vector<tagMCFuncOpenState> FuncStateList)// ¹¦ÄÜ״̬Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x02
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FuncCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FuncCount):
            temFuncStateList = tagMCFuncOpenState()
            _pos = temFuncStateList.ReadData(_lpData, _pos)
            self.FuncStateList.append(temFuncStateList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x02
        self.FuncCount = 0
        self.FuncStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.FuncCount):
            length += self.FuncStateList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FuncCount)
        for i in range(self.FuncCount):
            data = CommFunc.WriteString(data, self.FuncStateList[i].GetLength(), self.FuncStateList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FuncCount:%d,
                                FuncStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FuncCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFuncOpenStateList=tagMCFuncOpenStateList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFuncOpenStateList.Head.Cmd,m_NAtagMCFuncOpenStateList.Head.SubCmd))] = m_NAtagMCFuncOpenStateList


#------------------------------------------------------
# A3 1E Íæ¼Ò¾Û»ê¿×ÐÅÏ¢ #tagMCGatherSoulHoleInfo

class  tagMCGatherSoulHoleInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ¿×ÐÅÏ¢Êý
    GatherSoulDataList = list()    #(vector<DWORD> GatherSoulDataList)// ¿×Êý¾ÝÐÅÏ¢, Êý¾ÝÓë±³°üÊý¾ÝÏàͬ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1E
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.GatherSoulDataList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1E
        self.Count = 0
        self.GatherSoulDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.GatherSoulDataList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                GatherSoulDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGatherSoulHoleInfo=tagMCGatherSoulHoleInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGatherSoulHoleInfo.Head.Cmd,m_NAtagMCGatherSoulHoleInfo.Head.SubCmd))] = m_NAtagMCGatherSoulHoleInfo


#------------------------------------------------------
# A3 61 оۻê¿×ÐÅÏ¢ #tagMCGatherTheSoulHoleInfo

class  tagMCGatherTheSoulHoleInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ¿×Êý
    HoleSoulList = list()    #(vector<DWORD> HoleSoulList)// ¿×¾Û»êIDÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x61
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.HoleSoulList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x61
        self.Count = 0
        self.HoleSoulList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.HoleSoulList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                HoleSoulList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGatherTheSoulHoleInfo=tagMCGatherTheSoulHoleInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGatherTheSoulHoleInfo.Head.Cmd,m_NAtagMCGatherTheSoulHoleInfo.Head.SubCmd))] = m_NAtagMCGatherTheSoulHoleInfo


#------------------------------------------------------
# A3 60 оۻêÐÅÏ¢ #tagMCGatherTheSoulInfo

class  tagMCGatherTheSoul(Structure):
    _pack_ = 1
    _fields_ = [
                  ("SoulID", c_int),    
                  ("LV", 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.SoulID = 0
        self.LV = 0
        return

    def GetLength(self):
        return sizeof(tagMCGatherTheSoul)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 60 оۻêÐÅÏ¢ //tagMCGatherTheSoulInfo:
                                SoulID:%d,
                                LV:%d
                                '''\
                                %(
                                self.SoulID,
                                self.LV
                                )
        return DumpString


class  tagMCGatherTheSoulInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    SoulList = list()    #(vector<tagMCGatherTheSoul> SoulList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x60
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temSoulList = tagMCGatherTheSoul()
            _pos = temSoulList.ReadData(_lpData, _pos)
            self.SoulList.append(temSoulList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x60
        self.Count = 0
        self.SoulList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.SoulList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.SoulList[i].GetLength(), self.SoulList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                SoulList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGatherTheSoulInfo=tagMCGatherTheSoulInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGatherTheSoulInfo.Head.Cmd,m_NAtagMCGatherTheSoulInfo.Head.SubCmd))] = m_NAtagMCGatherTheSoulInfo


#------------------------------------------------------
# A3 1D Éñ±øµÈ¼¶ÐÅÏ¢ #tagMCGodWeaponLVList

class  tagMCGodWeaponLVInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("WeaponType", c_ubyte),    #Éñ±øÀàÐÍ
                  ("WeaponLV", c_ushort),    #Éñ±øµÈ¼¶
                  ("WeaponExp", 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.WeaponType = 0
        self.WeaponLV = 0
        self.WeaponExp = 0
        return

    def GetLength(self):
        return sizeof(tagMCGodWeaponLVInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 1D Éñ±øµÈ¼¶ÐÅÏ¢ //tagMCGodWeaponLVList:
                                WeaponType:%d,
                                WeaponLV:%d,
                                WeaponExp:%d
                                '''\
                                %(
                                self.WeaponType,
                                self.WeaponLV,
                                self.WeaponExp
                                )
        return DumpString


class  tagMCGodWeaponLVList(Structure):
    Head = tagHead()
    WeaponNum = 0    #(BYTE WeaponNum)//ÉñÆ÷¸öÊý
    WeaponInfoList = list()    #(vector<tagMCGodWeaponLVInfo> WeaponInfoList)// ¸±±¾Êý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1D
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.WeaponNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WeaponNum):
            temWeaponInfoList = tagMCGodWeaponLVInfo()
            _pos = temWeaponInfoList.ReadData(_lpData, _pos)
            self.WeaponInfoList.append(temWeaponInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1D
        self.WeaponNum = 0
        self.WeaponInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.WeaponNum):
            length += self.WeaponInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.WeaponNum)
        for i in range(self.WeaponNum):
            data = CommFunc.WriteString(data, self.WeaponInfoList[i].GetLength(), self.WeaponInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                WeaponNum:%d,
                                WeaponInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.WeaponNum,
                                "..."
                                )
        return DumpString


m_NAtagMCGodWeaponLVList=tagMCGodWeaponLVList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGodWeaponLVList.Head.Cmd,m_NAtagMCGodWeaponLVList.Head.SubCmd))] = m_NAtagMCGodWeaponLVList


#------------------------------------------------------
# A3 37 Ͷ×ÊÀí²ÆÐÅÏ¢ #tagMCGoldInvestInfo

class  tagMCInvestReward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RewardIndex", c_ushort),    # Ë÷Òý
                  ("RewardValue", c_ubyte),    # ¸ÃµÈ¼¶ÒÑÁìÈ¡Êý¾Ý£¬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.RewardIndex = 0
        self.RewardValue = 0
        return

    def GetLength(self):
        return sizeof(tagMCInvestReward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 37 Ͷ×ÊÀí²ÆÐÅÏ¢ //tagMCGoldInvestInfo:
                                RewardIndex:%d,
                                RewardValue:%d
                                '''\
                                %(
                                self.RewardIndex,
                                self.RewardValue
                                )
        return DumpString


class  tagMCGoldInvestInfo(Structure):
    Head = tagHead()
    InvestType = 0    #(BYTE InvestType)// Ͷ×ÊÀàÐÍ
    CurDay = 0    #(DWORD CurDay)// µ±Ç°ÌìÊý
    InvestGold = 0    #(DWORD InvestGold)// Ͷ×ʶî¶È
    RewardRecordCnt = 0    #(BYTE RewardRecordCnt)// Ͷ×ʻر¨¸öÊý
    InvestRewardList = list()    #(vector<tagMCInvestReward> InvestRewardList)// Ͷ×ʻر¨¼Ç¼
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x37
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.InvestType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CurDay,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.InvestGold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RewardRecordCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RewardRecordCnt):
            temInvestRewardList = tagMCInvestReward()
            _pos = temInvestRewardList.ReadData(_lpData, _pos)
            self.InvestRewardList.append(temInvestRewardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x37
        self.InvestType = 0
        self.CurDay = 0
        self.InvestGold = 0
        self.RewardRecordCnt = 0
        self.InvestRewardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.RewardRecordCnt):
            length += self.InvestRewardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.InvestType)
        data = CommFunc.WriteDWORD(data, self.CurDay)
        data = CommFunc.WriteDWORD(data, self.InvestGold)
        data = CommFunc.WriteBYTE(data, self.RewardRecordCnt)
        for i in range(self.RewardRecordCnt):
            data = CommFunc.WriteString(data, self.InvestRewardList[i].GetLength(), self.InvestRewardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                InvestType:%d,
                                CurDay:%d,
                                InvestGold:%d,
                                RewardRecordCnt:%d,
                                InvestRewardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.InvestType,
                                self.CurDay,
                                self.InvestGold,
                                self.RewardRecordCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCGoldInvestInfo=tagMCGoldInvestInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGoldInvestInfo.Head.Cmd,m_NAtagMCGoldInvestInfo.Head.SubCmd))] = m_NAtagMCGoldInvestInfo


#------------------------------------------------------
# A3 B9 ֪ͨÍæ¼Ò½ñÈÕÇÀºì°ü´ÎÊý #tagMCGrabRedPacketCnt

class  tagMCGrabRedPacketCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Cnt", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xB9
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xB9
        self.Cnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCGrabRedPacketCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 B9 ֪ͨÍæ¼Ò½ñÈÕÇÀºì°ü´ÎÊý //tagMCGrabRedPacketCnt:
                                Cmd:%s,
                                SubCmd:%s,
                                Cnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Cnt
                                )
        return DumpString


m_NAtagMCGrabRedPacketCnt=tagMCGrabRedPacketCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGrabRedPacketCnt.Cmd,m_NAtagMCGrabRedPacketCnt.SubCmd))] = m_NAtagMCGrabRedPacketCnt


#------------------------------------------------------
# A3 C7 ¹Å±¦ÐÅÏ¢ #tagMCGubaoInfo

class  tagMCGubao(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GubaoID", c_ushort),    
                  ("GubaoStar", c_ubyte),    
                  ("GubaoLV", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.GubaoID = 0
        self.GubaoStar = 0
        self.GubaoLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCGubao)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C7 ¹Å±¦ÐÅÏ¢ //tagMCGubaoInfo:
                                GubaoID:%d,
                                GubaoStar:%d,
                                GubaoLV:%d
                                '''\
                                %(
                                self.GubaoID,
                                self.GubaoStar,
                                self.GubaoLV
                                )
        return DumpString


class  tagMCGubaoInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    GubaoInfoList = list()    #(vector<tagMCGubao> GubaoInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC7
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temGubaoInfoList = tagMCGubao()
            _pos = temGubaoInfoList.ReadData(_lpData, _pos)
            self.GubaoInfoList.append(temGubaoInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC7
        self.Count = 0
        self.GubaoInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.GubaoInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.GubaoInfoList[i].GetLength(), self.GubaoInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                GubaoInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGubaoInfo=tagMCGubaoInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGubaoInfo.Head.Cmd,m_NAtagMCGubaoInfo.Head.SubCmd))] = m_NAtagMCGubaoInfo


#------------------------------------------------------
# A3 CA ¹Å±¦ÎïÆ·ÌØÊâЧ¹ûÐÅÏ¢ #tagMCGubaoItemEffInfo

class  tagMCGubaoItemEff(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GubaoID", c_ushort),    
                  ("EffType", c_ubyte),    # ²»Í¬¹Å±¦IDÔÊÐíÓµÓÐÏàͬЧ¹ûÀàÐÍ£¬½ø¶Èֵÿ¸ö¹Å±¦IDµ¥¶Àͳ¼Æ
                  ("EffValue", c_int),    # ¸ÃЧ¹ûÄ¿Ç°ÀÛ¼ÓÖµ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.GubaoID = 0
        self.EffType = 0
        self.EffValue = 0
        return

    def GetLength(self):
        return sizeof(tagMCGubaoItemEff)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 CA ¹Å±¦ÎïÆ·ÌØÊâЧ¹ûÐÅÏ¢ //tagMCGubaoItemEffInfo:
                                GubaoID:%d,
                                EffType:%d,
                                EffValue:%d
                                '''\
                                %(
                                self.GubaoID,
                                self.EffType,
                                self.EffValue
                                )
        return DumpString


class  tagMCGubaoItemEffInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)
    ItemEffInfoList = list()    #(vector<tagMCGubaoItemEff> ItemEffInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCA
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temItemEffInfoList = tagMCGubaoItemEff()
            _pos = temItemEffInfoList.ReadData(_lpData, _pos)
            self.ItemEffInfoList.append(temItemEffInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCA
        self.Count = 0
        self.ItemEffInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.ItemEffInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ItemEffInfoList[i].GetLength(), self.ItemEffInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ItemEffInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGubaoItemEffInfo=tagMCGubaoItemEffInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGubaoItemEffInfo.Head.Cmd,m_NAtagMCGubaoItemEffInfo.Head.SubCmd))] = m_NAtagMCGubaoItemEffInfo


#------------------------------------------------------
# A3 CB ¹Å±¦ËéƬÐÅÏ¢ #tagMCGubaoPieceInfo

class  tagMCGubaoPiece(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GubaoID", c_ushort),    
                  ("PieceCount", c_int),    # µ±Ç°ËéƬ¸öÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.GubaoID = 0
        self.PieceCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCGubaoPiece)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 CB ¹Å±¦ËéƬÐÅÏ¢ //tagMCGubaoPieceInfo:
                                GubaoID:%d,
                                PieceCount:%d
                                '''\
                                %(
                                self.GubaoID,
                                self.PieceCount
                                )
        return DumpString


class  tagMCGubaoPieceInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    PieceInfoList = list()    #(vector<tagMCGubaoPiece> PieceInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCB
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temPieceInfoList = tagMCGubaoPiece()
            _pos = temPieceInfoList.ReadData(_lpData, _pos)
            self.PieceInfoList.append(temPieceInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCB
        self.Count = 0
        self.PieceInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.PieceInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.PieceInfoList[i].GetLength(), self.PieceInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                PieceInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGubaoPieceInfo=tagMCGubaoPieceInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGubaoPieceInfo.Head.Cmd,m_NAtagMCGubaoPieceInfo.Head.SubCmd))] = m_NAtagMCGubaoPieceInfo


#------------------------------------------------------
# A3 28 ÀúÊ·ÀÛ»ý³äÖµ½±ÀøÁìÈ¡¼Ç¼ #tagMCHistoryReChargeAwardRecord

class  tagMCHistoryReChargeAwardRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AwardGetRecord", c_int),    # °´¶þ½øÖÆλ±êʾÁìÈ¡¼Ç¼ ÅäÖý±ÀøID´ú±íµÚ¼¸Î»
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x28
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x28
        self.AwardGetRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCHistoryReChargeAwardRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 28 ÀúÊ·ÀÛ»ý³äÖµ½±ÀøÁìÈ¡¼Ç¼ //tagMCHistoryReChargeAwardRecord:
                                Cmd:%s,
                                SubCmd:%s,
                                AwardGetRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AwardGetRecord
                                )
        return DumpString


m_NAtagMCHistoryReChargeAwardRecord=tagMCHistoryReChargeAwardRecord()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHistoryReChargeAwardRecord.Cmd,m_NAtagMCHistoryReChargeAwardRecord.SubCmd))] = m_NAtagMCHistoryReChargeAwardRecord


#------------------------------------------------------
# A3 12 ֪ͨÆï³è¾õÐÑÐÅÏ¢ #tagMCHorsePetSkinData

class  tagMCHorsePetSkinInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    # 1-×øÆï 2-Áé³è
                  ("ID", c_int),    # ¶ÔÓ¦×øÆï±íÁé³è±íID
                  ("Exp", c_int),    #¾­Ñé
                  ("SkinLV", c_ubyte),    #¾õÐѵȼ¶
                  ("SkinIndex", c_ubyte),    #µ±Ç°Ñ¡ÔñÍâ¹Û
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Type = 0
        self.ID = 0
        self.Exp = 0
        self.SkinLV = 0
        self.SkinIndex = 0
        return

    def GetLength(self):
        return sizeof(tagMCHorsePetSkinInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 12 ֪ͨÆï³è¾õÐÑÐÅÏ¢ //tagMCHorsePetSkinData:
                                Type:%d,
                                ID:%d,
                                Exp:%d,
                                SkinLV:%d,
                                SkinIndex:%d
                                '''\
                                %(
                                self.Type,
                                self.ID,
                                self.Exp,
                                self.SkinLV,
                                self.SkinIndex
                                )
        return DumpString


class  tagMCHorsePetSkinData(Structure):
    Head = tagHead()
    Num = 0    #(BYTE Num)//¸öÊý
    InfoList = list()    #(vector<tagMCHorsePetSkinInfo> InfoList)// Êý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x12
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Num,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Num):
            temInfoList = tagMCHorsePetSkinInfo()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x12
        self.Num = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Num):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Num)
        for i in range(self.Num):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Num:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Num,
                                "..."
                                )
        return DumpString


m_NAtagMCHorsePetSkinData=tagMCHorsePetSkinData()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorsePetSkinData.Head.Cmd,m_NAtagMCHorsePetSkinData.Head.SubCmd))] = m_NAtagMCHorsePetSkinData


#------------------------------------------------------
# A3 10 ֪ͨ×øÆï»Ã»¯Ê±Ð§ÐÅÏ¢ #tagMCHorseSkinTimeInfoList

class  tagMCHorseSkinTimeInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ID", c_int),    # ¶ÔÓ¦×øÆï»Ã»¯±íID
                  ("InvalidTime", c_int),    # ʧЧʱ¼ä´Á
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ID = 0
        self.InvalidTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCHorseSkinTimeInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 10 ֪ͨ×øÆï»Ã»¯Ê±Ð§ÐÅÏ¢ //tagMCHorseSkinTimeInfoList:
                                ID:%d,
                                InvalidTime:%d
                                '''\
                                %(
                                self.ID,
                                self.InvalidTime
                                )
        return DumpString


class  tagMCHorseSkinTimeInfoList(Structure):
    Head = tagHead()
    TimeCnt = 0    #(BYTE TimeCnt)//¸öÊý
    TimeInfoList = list()    #(vector<tagMCHorseSkinTimeInfo> TimeInfoList)// Êý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x10
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TimeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TimeCnt):
            temTimeInfoList = tagMCHorseSkinTimeInfo()
            _pos = temTimeInfoList.ReadData(_lpData, _pos)
            self.TimeInfoList.append(temTimeInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x10
        self.TimeCnt = 0
        self.TimeInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.TimeCnt):
            length += self.TimeInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TimeCnt)
        for i in range(self.TimeCnt):
            data = CommFunc.WriteString(data, self.TimeInfoList[i].GetLength(), self.TimeInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TimeCnt:%d,
                                TimeInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TimeCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCHorseSkinTimeInfoList=tagMCHorseSkinTimeInfoList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorseSkinTimeInfoList.Head.Cmd,m_NAtagMCHorseSkinTimeInfoList.Head.SubCmd))] = m_NAtagMCHorseSkinTimeInfoList


#------------------------------------------------------
# A3 CD ×øÆïÐǼ¶ÐÅÏ¢ #tagMCHorseStarInfo

class  tagMCHorseStar(Structure):
    _pack_ = 1
    _fields_ = [
                  ("HorseID", c_int),    # ×øÆï±íID
                  ("Star", c_ubyte),    # ÐǼ¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.HorseID = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCHorseStar)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 CD ×øÆïÐǼ¶ÐÅÏ¢ //tagMCHorseStarInfo:
                                HorseID:%d,
                                Star:%d
                                '''\
                                %(
                                self.HorseID,
                                self.Star
                                )
        return DumpString


class  tagMCHorseStarInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    HorseStarList = list()    #(vector<tagMCHorseStar> HorseStarList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCD
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temHorseStarList = tagMCHorseStar()
            _pos = temHorseStarList.ReadData(_lpData, _pos)
            self.HorseStarList.append(temHorseStarList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCD
        self.Count = 0
        self.HorseStarList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.HorseStarList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.HorseStarList[i].GetLength(), self.HorseStarList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                HorseStarList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCHorseStarInfo=tagMCHorseStarInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorseStarInfo.Head.Cmd,m_NAtagMCHorseStarInfo.Head.SubCmd))] = m_NAtagMCHorseStarInfo


#------------------------------------------------------
# A3 38 Ͷ×ÊÀí²ÆÐÅÏ¢ #tagMCInvestInfo

class  tagMCInvestInfo(Structure):
    Head = tagHead()
    InvestType = 0    #(BYTE InvestType)// Ͷ×ÊÀàÐÍ
    CurDay = 0    #(WORD CurDay)// µ±Ç°ÌìÊý£¬Í¶×ʵÚÒ»ÌìΪ1
    ValueCount = 0    #(BYTE ValueCount)
    RewardValue = list()    #(vector<DWORD> RewardValue)//Áì½±¼Ç¼ֵ£¬°´Í¶×ʻر¨Ë÷Òýλ¼Ç¼ÊÇ·ñÒÑÁìÈ¡
    ProgressValue = list()    #(vector<DWORD> ProgressValue)//Ͷ×ÊÏà¹Ø¿ÉÁìÈ¡½ø¶È¼Ç¼ֵ:  9µÇ¼Ͷ×Ê-¼Ç¼ÒѵǼÌìÊý£»11BossͶ×Ê-°´»Ø±¨Ë÷Òýλ¼Ç¼ÊÇ·ñÒÑ»÷ɱ¸Ãboss
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x38
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.InvestType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CurDay,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ValueCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.RewardValue.append(value)
        for i in range(self.ValueCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.ProgressValue.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x38
        self.InvestType = 0
        self.CurDay = 0
        self.ValueCount = 0
        self.RewardValue = list()
        self.ProgressValue = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 2
        length += 1
        length += 4 * self.ValueCount
        length += 4 * self.ValueCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.InvestType)
        data = CommFunc.WriteWORD(data, self.CurDay)
        data = CommFunc.WriteBYTE(data, self.ValueCount)
        for i in range(self.ValueCount):
            data = CommFunc.WriteDWORD(data, self.RewardValue[i])
        for i in range(self.ValueCount):
            data = CommFunc.WriteDWORD(data, self.ProgressValue[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                InvestType:%d,
                                CurDay:%d,
                                ValueCount:%d,
                                RewardValue:%s,
                                ProgressValue:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.InvestType,
                                self.CurDay,
                                self.ValueCount,
                                "...",
                                "..."
                                )
        return DumpString


m_NAtagMCInvestInfo=tagMCInvestInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCInvestInfo.Head.Cmd,m_NAtagMCInvestInfo.Head.SubCmd))] = m_NAtagMCInvestInfo


#------------------------------------------------------
# A3 55 Á¶ÌåÐÅÏ¢ #tagMCLianTiInfo

class  tagMCLianTiInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LianTiLV", c_ubyte),    #Á¶ÌåµÈ¼¶
                  ("EatItemCount", c_int),    #µ±Ç°µÈ¼¶ÒѳԵ¤¸öÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x55
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x55
        self.LianTiLV = 0
        self.EatItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCLianTiInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 55 Á¶ÌåÐÅÏ¢ //tagMCLianTiInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                LianTiLV:%d,
                                EatItemCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LianTiLV,
                                self.EatItemCount
                                )
        return DumpString


m_NAtagMCLianTiInfo=tagMCLianTiInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLianTiInfo.Cmd,m_NAtagMCLianTiInfo.SubCmd))] = m_NAtagMCLianTiInfo


#------------------------------------------------------
# A3 52 ·¨±¦µÈ¼¶ÐÅÏ¢ #tagMCMagicWeaponLVInfo

class  tagMCMagicWeaponInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MWID", c_int),    
                  ("LV", c_ubyte),    
                  ("Exp", c_int),    
                  ("FBPassLV", c_ubyte),    #¸±±¾¹Ø¿¨
                  ("IsWear", c_ubyte),    #ÊÇ·ñÅå´÷(½öÊÊÓÃÍõÕß·¨±¦)
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.MWID = 0
        self.LV = 0
        self.Exp = 0
        self.FBPassLV = 0
        self.IsWear = 0
        return

    def GetLength(self):
        return sizeof(tagMCMagicWeaponInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 52 ·¨±¦µÈ¼¶ÐÅÏ¢ //tagMCMagicWeaponLVInfo:
                                MWID:%d,
                                LV:%d,
                                Exp:%d,
                                FBPassLV:%d,
                                IsWear:%d
                                '''\
                                %(
                                self.MWID,
                                self.LV,
                                self.Exp,
                                self.FBPassLV,
                                self.IsWear
                                )
        return DumpString


class  tagMCMagicWeaponLVInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagMCMagicWeaponInfo> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x52
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCMagicWeaponInfo()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x52
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCMagicWeaponLVInfo=tagMCMagicWeaponLVInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMagicWeaponLVInfo.Head.Cmd,m_NAtagMCMagicWeaponLVInfo.Head.SubCmd))] = m_NAtagMCMagicWeaponLVInfo


#------------------------------------------------------
# A3 46 ´óʦ¾­ÑéÐÅÏ¢ #tagMCGreatMasterExp

class  tagMCGreatMasterExp(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MasterExpPoint", c_ushort),    #µ±Ç°´óʦ¾­Ñéµã
                  ("CurMasterEXP", c_int),    #µ±Ç°´óʦ¾­Ñé, ²»°üº¬¾­ÑéµãµÄ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x46
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x46
        self.MasterExpPoint = 0
        self.CurMasterEXP = 0
        return

    def GetLength(self):
        return sizeof(tagMCGreatMasterExp)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 46 ´óʦ¾­ÑéÐÅÏ¢ //tagMCGreatMasterExp:
                                Cmd:%s,
                                SubCmd:%s,
                                MasterExpPoint:%d,
                                CurMasterEXP:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MasterExpPoint,
                                self.CurMasterEXP
                                )
        return DumpString


m_NAtagMCGreatMasterExp=tagMCGreatMasterExp()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGreatMasterExp.Cmd,m_NAtagMCGreatMasterExp.SubCmd))] = m_NAtagMCGreatMasterExp


#------------------------------------------------------
# A3 C2 ´óʦǿ»¯µÈ¼¶¼¤»îÐÅÏ¢ #tagMCMasterPlusLVInfo

class  tagMCMasterPlusLV(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ClassLV", c_ubyte),    
                  ("MasterPlusLV", 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.ClassLV = 0
        self.MasterPlusLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCMasterPlusLV)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C2 ´óʦǿ»¯µÈ¼¶¼¤»îÐÅÏ¢ //tagMCMasterPlusLVInfo:
                                ClassLV:%d,
                                MasterPlusLV:%d
                                '''\
                                %(
                                self.ClassLV,
                                self.MasterPlusLV
                                )
        return DumpString


class  tagMCMasterPlusLVInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    MasterPlusLVInfoList = list()    #(vector<tagMCMasterPlusLV> MasterPlusLVInfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC2
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temMasterPlusLVInfoList = tagMCMasterPlusLV()
            _pos = temMasterPlusLVInfoList.ReadData(_lpData, _pos)
            self.MasterPlusLVInfoList.append(temMasterPlusLVInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC2
        self.Count = 0
        self.MasterPlusLVInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.MasterPlusLVInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.MasterPlusLVInfoList[i].GetLength(), self.MasterPlusLVInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                MasterPlusLVInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCMasterPlusLVInfo=tagMCMasterPlusLVInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMasterPlusLVInfo.Head.Cmd,m_NAtagMCMasterPlusLVInfo.Head.SubCmd))] = m_NAtagMCMasterPlusLVInfo


#------------------------------------------------------
#A3 1B Íæ¼Ò×Ô¶¯Õ½¶·ÉèÖô¢´æÐÅϢ֪ͨ#tagMCAutoFightSetting

class  tagMCAutoFightSetting(Structure):
    Head = tagHead()
    Size = 0    #(DWORD Size)
    Data = ""    #(String Data)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1B
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Size,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.Size)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1B
        self.Size = 0
        self.Data = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += len(self.Data)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.Size)
        data = CommFunc.WriteString(data, self.Size, self.Data)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Size:%d,
                                Data:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Size,
                                self.Data
                                )
        return DumpString


m_NAtagMCAutoFightSetting=tagMCAutoFightSetting()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAutoFightSetting.Head.Cmd,m_NAtagMCAutoFightSetting.Head.SubCmd))] = m_NAtagMCAutoFightSetting


#------------------------------------------------------
# A3 B3 ×°±¸²¿Î»Ç¿»¯ÐÅÏ¢ #tagMCEquipPartPlusInfo

class  tagMCEquipPartPlusLV(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PackType", c_ubyte),    
                  ("EquipIndex", c_ubyte),    
                  ("EquipPartStarLV", c_ushort),    
                  ("Proficiency", c_int),    
                  ("EvolveLV", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.PackType = 0
        self.EquipIndex = 0
        self.EquipPartStarLV = 0
        self.Proficiency = 0
        self.EvolveLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCEquipPartPlusLV)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 B3 ×°±¸²¿Î»Ç¿»¯ÐÅÏ¢ //tagMCEquipPartPlusInfo:
                                PackType:%d,
                                EquipIndex:%d,
                                EquipPartStarLV:%d,
                                Proficiency:%d,
                                EvolveLV:%d
                                '''\
                                %(
                                self.PackType,
                                self.EquipIndex,
                                self.EquipPartStarLV,
                                self.Proficiency,
                                self.EvolveLV
                                )
        return DumpString


class  tagMCEquipPartPlusInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ÐÅÏ¢¸öÊý
    InfoList = list()    #(vector<tagMCEquipPartPlusLV> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB3
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCEquipPartPlusLV()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xB3
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCEquipPartPlusInfo=tagMCEquipPartPlusInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEquipPartPlusInfo.Head.Cmd,m_NAtagMCEquipPartPlusInfo.Head.SubCmd))] = m_NAtagMCEquipPartPlusInfo


#------------------------------------------------------
#A3 1A Íæ¼ÒÁìÈ¡²¹³¥ÎïÆ··¢·Å½á¹û#tagMCGiveCompensationResult

class  tagMCGiveCompensationResult(Structure):
    Head = tagHead()
    GUID = ""    #(char GUID[40])
    Result = 0    #(BYTE Result)//·¢·Å²¹³¥½á¹û 1 ³É¹¦ 0 ʧ°Ü
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1A
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.GUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1A
        self.GUID = ""
        self.Result = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 40
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 40, self.GUID)
        data = CommFunc.WriteBYTE(data, self.Result)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                GUID:%s,
                                Result:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.GUID,
                                self.Result
                                )
        return DumpString


m_NAtagMCGiveCompensationResult=tagMCGiveCompensationResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGiveCompensationResult.Head.Cmd,m_NAtagMCGiveCompensationResult.Head.SubCmd))] = m_NAtagMCGiveCompensationResult


#------------------------------------------------------
#A3 A1 ¸÷¹¦ÄÜÄ£¿éÕ½¶·Á¦ÐÅÏ¢ #tagMCModuleFightPowerInfo

class  tagMCModuleFightPower(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MfpType", c_ubyte),    #Ä£¿é±àºÅÀàÐÍ
                  ("FightPower", 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.MfpType = 0
        self.FightPower = 0
        return

    def GetLength(self):
        return sizeof(tagMCModuleFightPower)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 A1 ¸÷¹¦ÄÜÄ£¿éÕ½¶·Á¦ÐÅÏ¢ //tagMCModuleFightPowerInfo:
                                MfpType:%d,
                                FightPower:%d
                                '''\
                                %(
                                self.MfpType,
                                self.FightPower
                                )
        return DumpString


class  tagMCModuleFightPowerInfo(Structure):
    Head = tagHead()
    TotalFightPower = 0    #(DWORD TotalFightPower)//×ÜÕ½¶·Á¦£¬ÇóÓàÒÚ²¿·Ö
    TotalFightPoweEx = 0    #(DWORD TotalFightPoweEx)//×ÜÕ½¶·Á¦£¬Õû³ýÒÚ²¿·Ö£¬1´ú±í1ÒÚ
    MFPCnt = 0    #(BYTE MFPCnt)//Ä£¿éÕ½¶·Á¦×ÜÊý
    MFPList = list()    #(vector<tagMCModuleFightPower> MFPList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xA1
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TotalFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalFightPoweEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MFPCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MFPCnt):
            temMFPList = tagMCModuleFightPower()
            _pos = temMFPList.ReadData(_lpData, _pos)
            self.MFPList.append(temMFPList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xA1
        self.TotalFightPower = 0
        self.TotalFightPoweEx = 0
        self.MFPCnt = 0
        self.MFPList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        for i in range(self.MFPCnt):
            length += self.MFPList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.TotalFightPower)
        data = CommFunc.WriteDWORD(data, self.TotalFightPoweEx)
        data = CommFunc.WriteBYTE(data, self.MFPCnt)
        for i in range(self.MFPCnt):
            data = CommFunc.WriteString(data, self.MFPList[i].GetLength(), self.MFPList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TotalFightPower:%d,
                                TotalFightPoweEx:%d,
                                MFPCnt:%d,
                                MFPList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TotalFightPower,
                                self.TotalFightPoweEx,
                                self.MFPCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCModuleFightPowerInfo=tagMCModuleFightPowerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCModuleFightPowerInfo.Head.Cmd,m_NAtagMCModuleFightPowerInfo.Head.SubCmd))] = m_NAtagMCModuleFightPowerInfo


#------------------------------------------------------
# A3 25 NPCÒѹ¥»÷´ÎÊýÐÅÏ¢ #tagMCNPCAttackCountInfo

class  tagMCNPCAttackCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NPCID", c_int),    
                  ("AttackCount", c_ubyte),    #Òѹ¥»÷´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.NPCID = 0
        self.AttackCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCAttackCount)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 25 NPCÒѹ¥»÷´ÎÊýÐÅÏ¢ //tagMCNPCAttackCountInfo:
                                NPCID:%d,
                                AttackCount:%d
                                '''\
                                %(
                                self.NPCID,
                                self.AttackCount
                                )
        return DumpString


class  tagMCNPCAttackCountInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    NPCAttackCountList = list()    #(vector<tagMCNPCAttackCount> NPCAttackCountList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x25
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temNPCAttackCountList = tagMCNPCAttackCount()
            _pos = temNPCAttackCountList.ReadData(_lpData, _pos)
            self.NPCAttackCountList.append(temNPCAttackCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x25
        self.Count = 0
        self.NPCAttackCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.NPCAttackCountList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.NPCAttackCountList[i].GetLength(), self.NPCAttackCountList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                NPCAttackCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCNPCAttackCountInfo=tagMCNPCAttackCountInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCAttackCountInfo.Head.Cmd,m_NAtagMCNPCAttackCountInfo.Head.SubCmd))] = m_NAtagMCNPCAttackCountInfo


#------------------------------------------------------
# A3 26 NPCIDÒѲɼ¯´ÎÊýÐÅÏ¢ #tagMCNPCIDCollectionCntInfo

class  tagMCNPCIDCollectionCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NPCID", c_int),    #NPCID
                  ("CollectionCnt", c_ubyte),    #ÒѲɼ¯´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.NPCID = 0
        self.CollectionCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCIDCollectionCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 26 NPCIDÒѲɼ¯´ÎÊýÐÅÏ¢ //tagMCNPCIDCollectionCntInfo:
                                NPCID:%d,
                                CollectionCnt:%d
                                '''\
                                %(
                                self.NPCID,
                                self.CollectionCnt
                                )
        return DumpString


class  tagMCNPCIDCollectionCntInfo(Structure):
    Head = tagHead()
    CollNPCCnt = 0    #(BYTE CollNPCCnt)//²É¼¯NPC¼Ç¼Êý
    NPCCollCntList = list()    #(vector<tagMCNPCIDCollectionCnt> NPCCollCntList)// ²É¼¯NPC´ÎÊý¼Ç¼Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x26
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CollNPCCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CollNPCCnt):
            temNPCCollCntList = tagMCNPCIDCollectionCnt()
            _pos = temNPCCollCntList.ReadData(_lpData, _pos)
            self.NPCCollCntList.append(temNPCCollCntList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x26
        self.CollNPCCnt = 0
        self.NPCCollCntList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.CollNPCCnt):
            length += self.NPCCollCntList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.CollNPCCnt)
        for i in range(self.CollNPCCnt):
            data = CommFunc.WriteString(data, self.NPCCollCntList[i].GetLength(), self.NPCCollCntList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CollNPCCnt:%d,
                                NPCCollCntList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CollNPCCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCNPCIDCollectionCntInfo=tagMCNPCIDCollectionCntInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCIDCollectionCntInfo.Head.Cmd,m_NAtagMCNPCIDCollectionCntInfo.Head.SubCmd))] = m_NAtagMCNPCIDCollectionCntInfo


#------------------------------------------------------
#A3 08 ÔÚÏß½±ÀøÐÅÏ¢ #tagMCOnlinePrize

class  tagMCOnlinePrize(Structure):
    Head = tagHead()
    OnlineTime = 0    #(DWORD OnlineTime)//ÔÚÏßʱ¼äºÁÃë
    Len = 0    #(BYTE Len)
    PrizeInfo = list()    #(vector<DWORD> PrizeInfo)//Áì½±¼Ç¼
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x08
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OnlineTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Len):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.PrizeInfo.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x08
        self.OnlineTime = 0
        self.Len = 0
        self.PrizeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 4 * self.Len

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.OnlineTime)
        data = CommFunc.WriteBYTE(data, self.Len)
        for i in range(self.Len):
            data = CommFunc.WriteDWORD(data, self.PrizeInfo[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OnlineTime:%d,
                                Len:%d,
                                PrizeInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OnlineTime,
                                self.Len,
                                "..."
                                )
        return DumpString


m_NAtagMCOnlinePrize=tagMCOnlinePrize()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOnlinePrize.Head.Cmd,m_NAtagMCOnlinePrize.Head.SubCmd))] = m_NAtagMCOnlinePrize


#------------------------------------------------------
# A3 19 ·Ö°üÏÂÔؽ±Àø¼Ç¼ #tagMCPackDownloadRecord

class  tagMCPackDownloadRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Record", c_ubyte),    #0-δÁìÈ¡ 1-ÒÑÁìÈ¡	
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x19
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x19
        self.Record = 0
        return

    def GetLength(self):
        return sizeof(tagMCPackDownloadRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 19 ·Ö°üÏÂÔؽ±Àø¼Ç¼ //tagMCPackDownloadRecord:
                                Cmd:%s,
                                SubCmd:%s,
                                Record:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Record
                                )
        return DumpString


m_NAtagMCPackDownloadRecord=tagMCPackDownloadRecord()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPackDownloadRecord.Cmd,m_NAtagMCPackDownloadRecord.SubCmd))] = m_NAtagMCPackDownloadRecord


#------------------------------------------------------
# A3 20 Íæ¼Ò¸±±¾Ïà¹ØÐÅÏ¢ #tagMCPlayerFBInfoData

class  tagMCFBInfo(Structure):
    FBID = 0    #(DWORD FBID)//fbId
    EnterCnt = 0    #(WORD EnterCnt)//µ±ÈÕ½øÈë´ÎÊý
    RecoverCnt = 0    #(WORD RecoverCnt)//ÕһشÎÊý
    ItemAddCnt = 0    #(WORD ItemAddCnt)//ÎïÆ·Ôö¼Ó´ÎÊý
    PassGradeCnt = 0    #(BYTE PassGradeCnt)//ÐǼ¶Öµ¶ÔÓ¦¸öÊý, ÿ¸ökey´æ9¸ölineID
    PassGrade = list()    #(vector<DWORD> PassGrade)//¸±±¾Ïß·¶ÔÓ¦ÐǼ¶ÖµÁбí
    EnterCntTotal = 0    #(DWORD EnterCntTotal)//ÀۼƽøÈë´ÎÊý
    PassLineID = 0    #(DWORD PassLineID)//Òѹý¹Øµ½µÄlineID
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.FBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EnterCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RecoverCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemAddCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PassGradeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PassGradeCnt):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.PassGrade.append(value)
        self.EnterCntTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PassLineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.FBID = 0
        self.EnterCnt = 0
        self.RecoverCnt = 0
        self.ItemAddCnt = 0
        self.PassGradeCnt = 0
        self.PassGrade = list()
        self.EnterCntTotal = 0
        self.PassLineID = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 2
        length += 2
        length += 2
        length += 1
        length += 4 * self.PassGradeCnt
        length += 4
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.FBID)
        data = CommFunc.WriteWORD(data, self.EnterCnt)
        data = CommFunc.WriteWORD(data, self.RecoverCnt)
        data = CommFunc.WriteWORD(data, self.ItemAddCnt)
        data = CommFunc.WriteBYTE(data, self.PassGradeCnt)
        for i in range(self.PassGradeCnt):
            data = CommFunc.WriteDWORD(data, self.PassGrade[i])
        data = CommFunc.WriteDWORD(data, self.EnterCntTotal)
        data = CommFunc.WriteDWORD(data, self.PassLineID)
        return data

    def OutputString(self):
        DumpString = '''
                                FBID:%d,
                                EnterCnt:%d,
                                RecoverCnt:%d,
                                ItemAddCnt:%d,
                                PassGradeCnt:%d,
                                PassGrade:%s,
                                EnterCntTotal:%d,
                                PassLineID:%d
                                '''\
                                %(
                                self.FBID,
                                self.EnterCnt,
                                self.RecoverCnt,
                                self.ItemAddCnt,
                                self.PassGradeCnt,
                                "...",
                                self.EnterCntTotal,
                                self.PassLineID
                                )
        return DumpString


class  tagMCPlayerFBInfoData(Structure):
    Head = tagHead()
    FBDataCnt = 0    #(BYTE FBDataCnt)// ¸±±¾Êý¾Ý¸öÊý
    FBDataList = list()    #(vector<tagMCFBInfo> FBDataList)// ¸±±¾Êý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x20
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FBDataCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FBDataCnt):
            temFBDataList = tagMCFBInfo()
            _pos = temFBDataList.ReadData(_lpData, _pos)
            self.FBDataList.append(temFBDataList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x20
        self.FBDataCnt = 0
        self.FBDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.FBDataCnt):
            length += self.FBDataList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FBDataCnt)
        for i in range(self.FBDataCnt):
            data = CommFunc.WriteString(data, self.FBDataList[i].GetLength(), self.FBDataList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FBDataCnt:%d,
                                FBDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FBDataCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPlayerFBInfoData=tagMCPlayerFBInfoData()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerFBInfoData.Head.Cmd,m_NAtagMCPlayerFBInfoData.Head.SubCmd))] = m_NAtagMCPlayerFBInfoData


#------------------------------------------------------
#A3 0B Íæ¼ÒµÈ¼¶½±ÀøÁìÈ¡¼Ç¼ÐÅÏ¢ #tagMCPlayerLVAwardGetRecord

class  tagMCPlayerLVAwardGetRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LVAwardGetRecord", c_int),    # °´¶þ½øÖÆλ±êʾÁìÈ¡¼Ç¼£¬Ã¿Î»¶ÔÓ¦µÄµÈ¼¶ÔÚÅä±íÖÐÅäÖ㬷þÎñ¶Ë¿Í»§¶Ë¶ÔÓ¦
                  ("VIPAwardRecord", c_int),    # °´¶þ½øÖÆλ±êʾvipÁìÈ¡¼Ç¼£¬Ã¿Î»¶ÔÓ¦µÄµÈ¼¶ÔÚÅä±íÖÐÅäÖ㬷þÎñ¶Ë¿Í»§¶Ë¶ÔÓ¦
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x0B
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x0B
        self.LVAwardGetRecord = 0
        self.VIPAwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerLVAwardGetRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 0B Íæ¼ÒµÈ¼¶½±ÀøÁìÈ¡¼Ç¼ÐÅÏ¢ //tagMCPlayerLVAwardGetRecord:
                                Cmd:%s,
                                SubCmd:%s,
                                LVAwardGetRecord:%d,
                                VIPAwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LVAwardGetRecord,
                                self.VIPAwardRecord
                                )
        return DumpString


m_NAtagMCPlayerLVAwardGetRecord=tagMCPlayerLVAwardGetRecord()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerLVAwardGetRecord.Cmd,m_NAtagMCPlayerLVAwardGetRecord.SubCmd))] = m_NAtagMCPlayerLVAwardGetRecord


#------------------------------------------------------
#A3 03 Íæ¼ÒÔÚÏß½±ÀøÐÅÏ¢(ÔÝͣʹÓÃ) #tagMCPlayerOnlinePrizeInfo

class  tagMCOnlinePrizeItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PrizeItem", c_int),    
                  ("ItemCount", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x03
        self.PrizeItem = 0
        self.ItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCOnlinePrizeItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 03 Íæ¼ÒÔÚÏß½±ÀøÐÅÏ¢(ÔÝͣʹÓÃ) //tagMCPlayerOnlinePrizeInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                PrizeItem:%d,
                                ItemCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PrizeItem,
                                self.ItemCount
                                )
        return DumpString


class  tagMCPlayerOnlinePrizeInfo(Structure):
    Head = tagHead()
    RemaindTime = 0    #(DWORD RemaindTime)//²úÉú½±ÀøÊ£Óàʱ¼ä
    HasPrize = 0    #(BYTE HasPrize)//ÊÇ·ñ¿ÉÒÔÁìÈ¡ 
    PrizeType = 0    #(BYTE PrizeType)//ÔÚÏß½±ÀøÀàÐÍ
    PrizeCnt = 0    #(BYTE PrizeCnt)//ÔÚÏß½±ÀøÀàÐÍ
    PrizeInfo = list()    #(vector<tagMCOnlinePrizeItem> PrizeInfo)//ÔÚÏß½±ÀøÀàÐÍ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RemaindTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HasPrize,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PrizeType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PrizeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PrizeCnt):
            temPrizeInfo = tagMCOnlinePrizeItem()
            _pos = temPrizeInfo.ReadData(_lpData, _pos)
            self.PrizeInfo.append(temPrizeInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x03
        self.RemaindTime = 0
        self.HasPrize = 0
        self.PrizeType = 0
        self.PrizeCnt = 0
        self.PrizeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        length += 1
        for i in range(self.PrizeCnt):
            length += self.PrizeInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.RemaindTime)
        data = CommFunc.WriteBYTE(data, self.HasPrize)
        data = CommFunc.WriteBYTE(data, self.PrizeType)
        data = CommFunc.WriteBYTE(data, self.PrizeCnt)
        for i in range(self.PrizeCnt):
            data = CommFunc.WriteString(data, self.PrizeInfo[i].GetLength(), self.PrizeInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RemaindTime:%d,
                                HasPrize:%d,
                                PrizeType:%d,
                                PrizeCnt:%d,
                                PrizeInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RemaindTime,
                                self.HasPrize,
                                self.PrizeType,
                                self.PrizeCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPlayerOnlinePrizeInfo=tagMCPlayerOnlinePrizeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerOnlinePrizeInfo.Head.Cmd,m_NAtagMCPlayerOnlinePrizeInfo.Head.SubCmd))] = m_NAtagMCPlayerOnlinePrizeInfo


#------------------------------------------------------
#A3 0C Íæ¼Ò¸÷½±ÀøÀàÐÍÁìÈ¡¼Ç¼ÐÅÏ¢ #tagMCPlayerRewardGetRecord

class  tagMCPlayerRewardGetRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("RewardType", c_ubyte),    #½±ÀøÀàÐÍ
                  ("RewardGetRecord", c_int),    # °´¶þ½øÖÆλ±êʾÁìÈ¡¼Ç¼
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x0C
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x0C
        self.RewardType = 0
        self.RewardGetRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerRewardGetRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 0C Íæ¼Ò¸÷½±ÀøÀàÐÍÁìÈ¡¼Ç¼ÐÅÏ¢ //tagMCPlayerRewardGetRecord:
                                Cmd:%s,
                                SubCmd:%s,
                                RewardType:%d,
                                RewardGetRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.RewardType,
                                self.RewardGetRecord
                                )
        return DumpString


m_NAtagMCPlayerRewardGetRecord=tagMCPlayerRewardGetRecord()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerRewardGetRecord.Cmd,m_NAtagMCPlayerRewardGetRecord.SubCmd))] = m_NAtagMCPlayerRewardGetRecord


#------------------------------------------------------
# A3 BF ֪ͨ¿Í»§¶ËÁ¶µ¤Â¯ÐÅÏ¢ #tagMCPlayerStoveMsg

class  tagMCPlayerStoveInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("AlchemyID", c_int),    # µ¤ ID
                  ("StartTime", c_int),    # ¿ªÊ¼Á¶µÄʱ¼ä 
                  ("AlchemyTimes", 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.AlchemyID = 0
        self.StartTime = 0
        self.AlchemyTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerStoveInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 BF ֪ͨ¿Í»§¶ËÁ¶µ¤Â¯ÐÅÏ¢ //tagMCPlayerStoveMsg:
                                AlchemyID:%d,
                                StartTime:%d,
                                AlchemyTimes:%d
                                '''\
                                %(
                                self.AlchemyID,
                                self.StartTime,
                                self.AlchemyTimes
                                )
        return DumpString


class  tagMCPlayerStoveMsg(Structure):
    Head = tagHead()
    StoveLV = 0    #(BYTE StoveLV)// Á¶µ¤Â¯µÈ¼¶
    StoveExp = 0    #(DWORD StoveExp)// Á¶µ¤Â¯¾­Ñé
    ItemID = 0    #(DWORD ItemID)// ºÏ³ÉÎïÆ·id
    ItemCnt = 0    #(WORD ItemCnt)// µ¤Ò©ÊýÁ¿
    StoveCnt = 0    #(WORD StoveCnt)// µ¤Ò©ÊýÁ¿
    InfoList = list()    #(vector<tagMCPlayerStoveInfo> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBF
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StoveLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StoveExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.StoveCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.StoveCnt):
            temInfoList = tagMCPlayerStoveInfo()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBF
        self.StoveLV = 0
        self.StoveExp = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.StoveCnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 4
        length += 2
        length += 2
        for i in range(self.StoveCnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.StoveLV)
        data = CommFunc.WriteDWORD(data, self.StoveExp)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCnt)
        data = CommFunc.WriteWORD(data, self.StoveCnt)
        for i in range(self.StoveCnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StoveLV:%d,
                                StoveExp:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                StoveCnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StoveLV,
                                self.StoveExp,
                                self.ItemID,
                                self.ItemCnt,
                                self.StoveCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPlayerStoveMsg=tagMCPlayerStoveMsg()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerStoveMsg.Head.Cmd,m_NAtagMCPlayerStoveMsg.Head.SubCmd))] = m_NAtagMCPlayerStoveMsg


#------------------------------------------------------
# A3 21 Æí¸£µ¤Ò©½á¹û #tagMCPrayElixirResult

class  tagMCPrayElixirResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("PrayCnt", c_ubyte),    # ½ñÈÕÆí¸£´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x21
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x21
        self.ItemID = 0
        self.PrayCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCPrayElixirResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 21 Æí¸£µ¤Ò©½á¹û //tagMCPrayElixirResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ItemID:%d,
                                PrayCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ItemID,
                                self.PrayCnt
                                )
        return DumpString


m_NAtagMCPrayElixirResult=tagMCPrayElixirResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPrayElixirResult.Cmd,m_NAtagMCPrayElixirResult.SubCmd))] = m_NAtagMCPrayElixirResult


#------------------------------------------------------
# A3 27 ¾³½çÐÞΪ³ØÐÅÏ¢ #tagMCRealmExpInfo

class  tagMCRealmExpInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("BeginTime", c_int),    #¿ªÊ¼¼Æʱʱ¼ä
                  ("BuffTime", c_int),    #buffÊ£Óàʱ¼ä
                  ("BuffAddRate", c_int),    #buff¼Ó³ÉÍò·ÖÂÊ
                  ("CurExp", c_int),    #µ±Ç°×ܾ­Ñé
                  ("CurExpPoint", c_int),    #µ±Ç°×ܾ­Ñéµã
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x27
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x27
        self.BeginTime = 0
        self.BuffTime = 0
        self.BuffAddRate = 0
        self.CurExp = 0
        self.CurExpPoint = 0
        return

    def GetLength(self):
        return sizeof(tagMCRealmExpInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 27 ¾³½çÐÞΪ³ØÐÅÏ¢ //tagMCRealmExpInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                BeginTime:%d,
                                BuffTime:%d,
                                BuffAddRate:%d,
                                CurExp:%d,
                                CurExpPoint:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.BeginTime,
                                self.BuffTime,
                                self.BuffAddRate,
                                self.CurExp,
                                self.CurExpPoint
                                )
        return DumpString


m_NAtagMCRealmExpInfo=tagMCRealmExpInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRealmExpInfo.Cmd,m_NAtagMCRealmExpInfo.SubCmd))] = m_NAtagMCRealmExpInfo


#------------------------------------------------------
# A3 49 ×ÊÔ´ÕһشÎÊý #tagMCRecoverNum

class  tagMCRecoverNumInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Index", c_ubyte),    # ÕÒ»ØÏîË÷Òý
                  ("RecoverCnt", c_ubyte),    # ¿ÉÕһشÎÊý
                  ("ExtraCnt", c_ubyte),    # VIP¶îÍâ´ÎÊý
                  ("ExtraData", c_ubyte),    # ¶îÍâ²ÎÊý1
                  ("ExtraData2", c_ubyte),    # ¶îÍâ²ÎÊý2
                  ("HaveRecover", c_ubyte),    # ÒÑÕÒ»Ø 1-È«²¿ÒÑÕÒ»Ø 2-·ÇVIPÒÑÕÒ»Ø
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Index = 0
        self.RecoverCnt = 0
        self.ExtraCnt = 0
        self.ExtraData = 0
        self.ExtraData2 = 0
        self.HaveRecover = 0
        return

    def GetLength(self):
        return sizeof(tagMCRecoverNumInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 49 ×ÊÔ´ÕһشÎÊý //tagMCRecoverNum:
                                Index:%d,
                                RecoverCnt:%d,
                                ExtraCnt:%d,
                                ExtraData:%d,
                                ExtraData2:%d,
                                HaveRecover:%d
                                '''\
                                %(
                                self.Index,
                                self.RecoverCnt,
                                self.ExtraCnt,
                                self.ExtraData,
                                self.ExtraData2,
                                self.HaveRecover
                                )
        return DumpString


class  tagMCRecoverNum(Structure):
    Head = tagHead()
    Num = 0    #(BYTE Num)// ÕÒ»ØÐÅÏ¢Êý
    NumInfo = list()    #(vector<tagMCRecoverNumInfo> NumInfo)// ÕÒ»ØÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x49
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Num,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Num):
            temNumInfo = tagMCRecoverNumInfo()
            _pos = temNumInfo.ReadData(_lpData, _pos)
            self.NumInfo.append(temNumInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x49
        self.Num = 0
        self.NumInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Num):
            length += self.NumInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Num)
        for i in range(self.Num):
            data = CommFunc.WriteString(data, self.NumInfo[i].GetLength(), self.NumInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Num:%d,
                                NumInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Num,
                                "..."
                                )
        return DumpString


m_NAtagMCRecoverNum=tagMCRecoverNum()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRecoverNum.Head.Cmd,m_NAtagMCRecoverNum.Head.SubCmd))] = m_NAtagMCRecoverNum


#------------------------------------------------------
# A3 1F Íæ¼Ò·ûÓ¡ÐÅÏ¢ #tagMCRuneInfo

class  tagMCRuneInfo(Structure):
    Head = tagHead()
    RuneHoleOpenState = 0    #(DWORD RuneHoleOpenState)//·ûÓ¡¿×״̬, °´Ë÷Òý±íʾ¼¤»î״̬
    Count = 0    #(BYTE Count)// ·ûÓ¡¿×ÐÅÏ¢Êý
    RuneDataList = list()    #(vector<DWORD> RuneDataList)// ·ûÓ¡¿×Êý¾ÝÐÅÏ¢, Êý¾ÝÓë±³°üÊý¾ÝÏàͬ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1F
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RuneHoleOpenState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.RuneDataList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x1F
        self.RuneHoleOpenState = 0
        self.Count = 0
        self.RuneDataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.RuneHoleOpenState)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.RuneDataList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RuneHoleOpenState:%d,
                                Count:%d,
                                RuneDataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RuneHoleOpenState,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCRuneInfo=tagMCRuneInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRuneInfo.Head.Cmd,m_NAtagMCRuneInfo.Head.SubCmd))] = m_NAtagMCRuneInfo


#------------------------------------------------------
# A3 C8 ÉñͨµÈ¼¶ÐÅÏ¢ #tagMCShentongLVInfo

class  tagMCShentongLV(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ShentongID", c_ubyte),    
                  ("ClassLV", c_ubyte),    
                  ("LV", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ShentongID = 0
        self.ClassLV = 0
        self.LV = 0
        return

    def GetLength(self):
        return sizeof(tagMCShentongLV)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 C8 ÉñͨµÈ¼¶ÐÅÏ¢ //tagMCShentongLVInfo:
                                ShentongID:%d,
                                ClassLV:%d,
                                LV:%d
                                '''\
                                %(
                                self.ShentongID,
                                self.ClassLV,
                                self.LV
                                )
        return DumpString


class  tagMCShentongLVInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    ShentongLVList = list()    #(vector<tagMCShentongLV> ShentongLVList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC8
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temShentongLVList = tagMCShentongLV()
            _pos = temShentongLVList.ReadData(_lpData, _pos)
            self.ShentongLVList.append(temShentongLVList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC8
        self.Count = 0
        self.ShentongLVList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.ShentongLVList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ShentongLVList[i].GetLength(), self.ShentongLVList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ShentongLVList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCShentongLVInfo=tagMCShentongLVInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShentongLVInfo.Head.Cmd,m_NAtagMCShentongLVInfo.Head.SubCmd))] = m_NAtagMCShentongLVInfo


#------------------------------------------------------
# A3 C9 Éñͨ¼¼ÄÜÉèÖÃÐÅÏ¢ #tagMCShentongSkillInfo

class  tagMCShentongSkillInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    SkillIDList = list()    #(vector<DWORD> SkillIDList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC9
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.SkillIDList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xC9
        self.Count = 0
        self.SkillIDList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.SkillIDList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                SkillIDList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCShentongSkillInfo=tagMCShentongSkillInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShentongSkillInfo.Head.Cmd,m_NAtagMCShentongSkillInfo.Head.SubCmd))] = m_NAtagMCShentongSkillInfo


#------------------------------------------------------
# A3 44 µ±ÈÕÀۼƳäÖµ¶àÑ¡Ò»Àñ°üÐÅÏ¢ #tagMCSingleGoldGift

class  tagMCSingleGoldGift(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GoldCnt", c_int),    # ½ñÈÕÒѳäÖµÔª±¦Êý
                  ("GiftIndex", c_ubyte),    # ÒÑÁìÈ¡Àñ°üË÷Òý, 0-δÁìÈ¡,>0ÒÑÁìÈ¡µÄË÷Òý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x44
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x44
        self.GoldCnt = 0
        self.GiftIndex = 0
        return

    def GetLength(self):
        return sizeof(tagMCSingleGoldGift)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 44 µ±ÈÕÀۼƳäÖµ¶àÑ¡Ò»Àñ°üÐÅÏ¢ //tagMCSingleGoldGift:
                                Cmd:%s,
                                SubCmd:%s,
                                GoldCnt:%d,
                                GiftIndex:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GoldCnt,
                                self.GiftIndex
                                )
        return DumpString


m_NAtagMCSingleGoldGift=tagMCSingleGoldGift()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSingleGoldGift.Cmd,m_NAtagMCSingleGoldGift.SubCmd))] = m_NAtagMCSingleGoldGift


#------------------------------------------------------
# A3 09 ¼¼ÄÜÎåÐÐר¾«ÐÅÏ¢ #tagMCSkillElementInfo

class  tagMCSkillElementActiveData(Structure):
    _pack_ = 1
    _fields_ = [
                  ("SkillID", c_int),    # ¼¼ÄÜID
                  ("ActiveLV", c_ubyte),    # ¼¤»îµÈ¼¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.SkillID = 0
        self.ActiveLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCSkillElementActiveData)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 09 ¼¼ÄÜÎåÐÐר¾«ÐÅÏ¢ //tagMCSkillElementInfo:
                                SkillID:%d,
                                ActiveLV:%d
                                '''\
                                %(
                                self.SkillID,
                                self.ActiveLV
                                )
        return DumpString


class  tagMCSkillElementData(Structure):
    MainSkillID = 0    #(DWORD MainSkillID)// Ö÷¼¼ÄÜID
    ElementSkillID = 0    #(DWORD ElementSkillID)// Ñ¡ÔñµÄר¾«¼¼ÄÜID
    SkillCnt = 0    #(BYTE SkillCnt)// ÊýÁ¿
    ActiveSkill = list()    #(vector<tagMCSkillElementActiveData> ActiveSkill)// ¼¤»îµÄ¼¼ÄÜID
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.MainSkillID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ElementSkillID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SkillCnt):
            temActiveSkill = tagMCSkillElementActiveData()
            _pos = temActiveSkill.ReadData(_lpData, _pos)
            self.ActiveSkill.append(temActiveSkill)
        return _pos

    def Clear(self):
        self.MainSkillID = 0
        self.ElementSkillID = 0
        self.SkillCnt = 0
        self.ActiveSkill = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 1
        for i in range(self.SkillCnt):
            length += self.ActiveSkill[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.MainSkillID)
        data = CommFunc.WriteDWORD(data, self.ElementSkillID)
        data = CommFunc.WriteBYTE(data, self.SkillCnt)
        for i in range(self.SkillCnt):
            data = CommFunc.WriteString(data, self.ActiveSkill[i].GetLength(), self.ActiveSkill[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                MainSkillID:%d,
                                ElementSkillID:%d,
                                SkillCnt:%d,
                                ActiveSkill:%s
                                '''\
                                %(
                                self.MainSkillID,
                                self.ElementSkillID,
                                self.SkillCnt,
                                "..."
                                )
        return DumpString


class  tagMCSkillElementInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// ÊýÁ¿
    InfoList = list()    #(vector<tagMCSkillElementData> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCSkillElementData()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x09
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCSkillElementInfo=tagMCSkillElementInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSkillElementInfo.Head.Cmd,m_NAtagMCSkillElementInfo.Head.SubCmd))] = m_NAtagMCSkillElementInfo


#------------------------------------------------------
# A3 BC ֪ͨװ±¸Î»¿×λ±¦Ê¯ID #tagMCStoneInfo

class  tagMCStoneMsg(Structure):
    EquipPlace = 0    #(BYTE EquipPlace)// ×°±¸Î»    
    MaxStoneCount = 0    #(BYTE MaxStoneCount)// ×î´ó¿×Êý
    StoneInfo = list()    #(vector<DWORD> StoneInfo)// ¿×ÄÚ±¦Ê¯ÐÅÏ¢
    StoneBind = list()    #(vector<BYTE> StoneBind)// ¿×ÄÚ±¦Ê¯ÊÇ·ñ°ó¶¨
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.EquipPlace,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MaxStoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MaxStoneCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.StoneInfo.append(value)
        for i in range(self.MaxStoneCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.StoneBind.append(value)
        return _pos

    def Clear(self):
        self.EquipPlace = 0
        self.MaxStoneCount = 0
        self.StoneInfo = list()
        self.StoneBind = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 4 * self.MaxStoneCount
        length += 1 * self.MaxStoneCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.EquipPlace)
        data = CommFunc.WriteBYTE(data, self.MaxStoneCount)
        for i in range(self.MaxStoneCount):
            data = CommFunc.WriteDWORD(data, self.StoneInfo[i])
        for i in range(self.MaxStoneCount):
            data = CommFunc.WriteBYTE(data, self.StoneBind[i])
        return data

    def OutputString(self):
        DumpString = '''
                                EquipPlace:%d,
                                MaxStoneCount:%d,
                                StoneInfo:%s,
                                StoneBind:%s
                                '''\
                                %(
                                self.EquipPlace,
                                self.MaxStoneCount,
                                "...",
                                "..."
                                )
        return DumpString


class  tagMCStoneInfo(Structure):
    Head = tagHead()
    EquipCount = 0    #(BYTE EquipCount)// ×°±¸Î»¸öÊý
    InfoList = list()    #(vector<tagMCStoneMsg> InfoList)// ×°±¸Î»¿×ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBC
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.EquipCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.EquipCount):
            temInfoList = tagMCStoneMsg()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xBC
        self.EquipCount = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.EquipCount):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.EquipCount)
        for i in range(self.EquipCount):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                EquipCount:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.EquipCount,
                                "..."
                                )
        return DumpString


m_NAtagMCStoneInfo=tagMCStoneInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCStoneInfo.Head.Cmd,m_NAtagMCStoneInfo.Head.SubCmd))] = m_NAtagMCStoneInfo


#------------------------------------------------------
# A3 41  ³É¾ÍÍê³É #tagMCSuccessFinish

class  tagMCSuccessFinish(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("SuccID", c_int),    #³É¾Íid
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x41
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x41
        self.SuccID = 0
        return

    def GetLength(self):
        return sizeof(tagMCSuccessFinish)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 41  ³É¾ÍÍê³É //tagMCSuccessFinish:
                                Cmd:%s,
                                SubCmd:%s,
                                SuccID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.SuccID
                                )
        return DumpString


m_NAtagMCSuccessFinish=tagMCSuccessFinish()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuccessFinish.Cmd,m_NAtagMCSuccessFinish.SubCmd))] = m_NAtagMCSuccessFinish


#------------------------------------------------------
#A3 42  ³É¾ÍÍê³ÉÁì½±¼Ç¼Áбí #tagMCSuccessFinishAwardRecordList

class  tagMCSuccessFinishAwardRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RecordIndex", c_ushort),    #µÚ¼¸¸ö¼Ç¼ֵ ÿ¸ökey´æ31¸ösuccid   0-30Ϊ0, 31-61Ϊ1..
                  ("Record", c_int),    #¶ÔÓ¦ÊÇ·ñÁìÈ¡Öµ
                  ("PassportRecord", 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.RecordIndex = 0
        self.Record = 0
        self.PassportRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCSuccessFinishAwardRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 42  ³É¾ÍÍê³ÉÁì½±¼Ç¼Áбí //tagMCSuccessFinishAwardRecordList:
                                RecordIndex:%d,
                                Record:%d,
                                PassportRecord:%d
                                '''\
                                %(
                                self.RecordIndex,
                                self.Record,
                                self.PassportRecord
                                )
        return DumpString


class  tagMCSuccessFinishAwardRecordList(Structure):
    Head = tagHead()
    RecordCnt = 0    #(WORD RecordCnt)//¼Ç¼¸öÊý
    RecordList = list()    #(vector<tagMCSuccessFinishAwardRecord> RecordList)//¼Ç¼Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x42
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RecordCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RecordCnt):
            temRecordList = tagMCSuccessFinishAwardRecord()
            _pos = temRecordList.ReadData(_lpData, _pos)
            self.RecordList.append(temRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x42
        self.RecordCnt = 0
        self.RecordList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.RecordCnt):
            length += self.RecordList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RecordCnt)
        for i in range(self.RecordCnt):
            data = CommFunc.WriteString(data, self.RecordList[i].GetLength(), self.RecordList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RecordCnt:%d,
                                RecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RecordCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCSuccessFinishAwardRecordList=tagMCSuccessFinishAwardRecordList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuccessFinishAwardRecordList.Head.Cmd,m_NAtagMCSuccessFinishAwardRecordList.Head.SubCmd))] = m_NAtagMCSuccessFinishAwardRecordList


#------------------------------------------------------
# A3 40  ³É¾ÍÐÅÏ¢Áбí #tagMCSuccessInfoList

class  tagMCSuccessInfo(Structure):
    SuccType = 0    #(WORD SuccType)//³É¾ÍÀàÐÍ
    Len = 0    #(WORD Len)//Ìõ¼þ³¤¶È
    Condition = ""    #(String Condition)//³É¾ÍÌõ¼þ
    CntValue = 0    #(DWORD CntValue)//µ±Ç°Íê³É½ø¶ÈÖµ
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.SuccType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Condition,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        self.CntValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.SuccType = 0
        self.Len = 0
        self.Condition = ""
        self.CntValue = 0
        return

    def GetLength(self):
        length = 0
        length += 2
        length += 2
        length += len(self.Condition)
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteWORD(data, self.SuccType)
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.Condition)
        data = CommFunc.WriteDWORD(data, self.CntValue)
        return data

    def OutputString(self):
        DumpString = '''
                                SuccType:%d,
                                Len:%d,
                                Condition:%s,
                                CntValue:%d
                                '''\
                                %(
                                self.SuccType,
                                self.Len,
                                self.Condition,
                                self.CntValue
                                )
        return DumpString


class  tagMCSuccessInfoList(Structure):
    Head = tagHead()
    count = 0    #(WORD count)//ÐÅÏ¢¸öÊý
    SuccessInfoList = list()    #(vector<tagMCSuccessInfo> SuccessInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x40
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.count):
            temSuccessInfoList = tagMCSuccessInfo()
            _pos = temSuccessInfoList.ReadData(_lpData, _pos)
            self.SuccessInfoList.append(temSuccessInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x40
        self.count = 0
        self.SuccessInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.count):
            length += self.SuccessInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.count)
        for i in range(self.count):
            data = CommFunc.WriteString(data, self.SuccessInfoList[i].GetLength(), self.SuccessInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                count:%d,
                                SuccessInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.count,
                                "..."
                                )
        return DumpString


m_NAtagMCSuccessInfoList=tagMCSuccessInfoList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuccessInfoList.Head.Cmd,m_NAtagMCSuccessInfoList.Head.SubCmd))] = m_NAtagMCSuccessInfoList


#------------------------------------------------------
# A3 43  ³É¾Í»ý·ÖÐÅÏ¢ #tagMCSuccessScoreInfo

class  tagMCSuccessScoreInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ScoreAwardState", c_int),    #³É¾Í»ý·ÖÁì½±¼Ç¼£¬°´½±ÀøË÷Òýλ¼Ç¼ÊÇ·ñÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x43
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x43
        self.ScoreAwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCSuccessScoreInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 43  ³É¾Í»ý·ÖÐÅÏ¢ //tagMCSuccessScoreInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ScoreAwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ScoreAwardState
                                )
        return DumpString


m_NAtagMCSuccessScoreInfo=tagMCSuccessScoreInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuccessScoreInfo.Cmd,m_NAtagMCSuccessScoreInfo.SubCmd))] = m_NAtagMCSuccessScoreInfo


#------------------------------------------------------
#A3 14 ֪ͨ¸÷¹¦ÄܵÄ×£¸£Öµ  #tagMCSyncBlessValue

class  tagMCSyncSingleBlessValue(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Type", c_ubyte),    #¹¦ÄÜÀàÐÍ×£¸£
                  ("Value", c_int),    #µ±Ç°×£¸£Öµ
                  ("Multiple", c_ubyte),    #±¶Êý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x14
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x14
        self.Type = 0
        self.Value = 0
        self.Multiple = 0
        return

    def GetLength(self):
        return sizeof(tagMCSyncSingleBlessValue)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 14 ֪ͨ¸÷¹¦ÄܵÄ×£¸£Öµ  //tagMCSyncBlessValue:
                                Cmd:%s,
                                SubCmd:%s,
                                Type:%d,
                                Value:%d,
                                Multiple:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Type,
                                self.Value,
                                self.Multiple
                                )
        return DumpString


class  tagMCSyncBlessValue(Structure):
    Head = tagHead()
    TypeCnt = 0    #(BYTE TypeCnt)//×£¸£ÖµÖÖÀà¸öÊý
    BlessInfo = list()    #(vector<tagMCSyncSingleBlessValue> BlessInfo)//×£¸£ÖµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x14
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TypeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TypeCnt):
            temBlessInfo = tagMCSyncSingleBlessValue()
            _pos = temBlessInfo.ReadData(_lpData, _pos)
            self.BlessInfo.append(temBlessInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x14
        self.TypeCnt = 0
        self.BlessInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.TypeCnt):
            length += self.BlessInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TypeCnt)
        for i in range(self.TypeCnt):
            data = CommFunc.WriteString(data, self.BlessInfo[i].GetLength(), self.BlessInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TypeCnt:%d,
                                BlessInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TypeCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCSyncBlessValue=tagMCSyncBlessValue()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSyncBlessValue.Head.Cmd,m_NAtagMCSyncBlessValue.Head.SubCmd))] = m_NAtagMCSyncBlessValue


#------------------------------------------------------
#A3 13 ֪ͨ¾ôλºÍÐÇ×ù # tagMCSyncOfficialRankStar

class  tagMCSyncOfficialRankStar(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("RankLV", c_ubyte),    #¾ôλµÈ¼¶
                  ("StarIndex", c_ubyte),    #ÐÇλ
                  ("PrestigeNum", c_int),    #ÉùÍû
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x13
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x13
        self.RankLV = 0
        self.StarIndex = 0
        self.PrestigeNum = 0
        return

    def GetLength(self):
        return sizeof(tagMCSyncOfficialRankStar)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 13 ֪ͨ¾ôλºÍÐÇ×ù // tagMCSyncOfficialRankStar:
                                Cmd:%s,
                                SubCmd:%s,
                                RankLV:%d,
                                StarIndex:%d,
                                PrestigeNum:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.RankLV,
                                self.StarIndex,
                                self.PrestigeNum
                                )
        return DumpString


m_NAtagMCSyncOfficialRankStar=tagMCSyncOfficialRankStar()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSyncOfficialRankStar.Cmd,m_NAtagMCSyncOfficialRankStar.SubCmd))] = m_NAtagMCSyncOfficialRankStar


#------------------------------------------------------
# A3 11 ֪ͨÍæ¼Ò¾³½çÐÅÏ¢ #tagMCSyncRealmInfo

class  tagMCSyncRealmInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsPass", c_ubyte),    #ÊÇ·ñͨ¹Ø¸±±¾
                  ("XXZLAwardState", c_int),    #ÐÞÏÉ֮·Á콱״̬£»°´¶þ½øÖÆλ´æ´¢Ã¿¸öÈÎÎñIDÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x11
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x11
        self.IsPass = 0
        self.XXZLAwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCSyncRealmInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 11 ֪ͨÍæ¼Ò¾³½çÐÅÏ¢ //tagMCSyncRealmInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                IsPass:%d,
                                XXZLAwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsPass,
                                self.XXZLAwardState
                                )
        return DumpString


m_NAtagMCSyncRealmInfo=tagMCSyncRealmInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSyncRealmInfo.Cmd,m_NAtagMCSyncRealmInfo.SubCmd))] = m_NAtagMCSyncRealmInfo


#------------------------------------------------------
# A3 CE ³ÆºÅÐǼ¶ÐÅÏ¢ #tagMCTitleStarInfo

class  tagMCTitleStar(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TitleID", c_int),    # ³ÆºÅID
                  ("Star", c_ubyte),    # ÐǼ¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.TitleID = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCTitleStar)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 CE ³ÆºÅÐǼ¶ÐÅÏ¢ //tagMCTitleStarInfo:
                                TitleID:%d,
                                Star:%d
                                '''\
                                %(
                                self.TitleID,
                                self.Star
                                )
        return DumpString


class  tagMCTitleStarInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    TitleStarList = list()    #(vector<tagMCTitleStar> TitleStarList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCE
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temTitleStarList = tagMCTitleStar()
            _pos = temTitleStarList.ReadData(_lpData, _pos)
            self.TitleStarList.append(temTitleStarList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0xCE
        self.Count = 0
        self.TitleStarList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.TitleStarList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.TitleStarList[i].GetLength(), self.TitleStarList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                TitleStarList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCTitleStarInfo=tagMCTitleStarInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTitleStarInfo.Head.Cmd,m_NAtagMCTitleStarInfo.Head.SubCmd))] = m_NAtagMCTitleStarInfo


#------------------------------------------------------
# A3 56 ͨÌìÁîÐÅÏ¢ #tagMCTongTianLingInfo

class  tagMCTongTianLingInfo(Structure):
    Head = tagHead()
    TTLBuyState = 0    #(BYTE TTLBuyState)//ͨÌìÁîÊÇ·ñÒѹºÂò
    TTLLV = 0    #(BYTE TTLLV)//ͨÌìÁîµÈ¼¶£¬´Ó0¿ªÊ¼
    CurPoint = 0    #(DWORD CurPoint)//ͨÌìÁǰµÈ¼¶¾­Ñé»ý·Öµã
    AwardStateCount = 0    #(BYTE AwardStateCount)//µÈ¼¶Áì½±¼Ç¼ֵÊý£¬Ã¿¸öÖµ´æ31¸ö¼Ç¼   0-30, 31-61, ...
    CommAwardStateList = list()    #(vector<DWORD> CommAwardStateList)//³£¹æ½±ÀøÁì½±¼Ç¼£¬°´µÈ¼¶¶þ½øÖÆλ´æ´¢ÊÇ·ñÁì½±
    XianAwardStateList = list()    #(vector<DWORD> XianAwardStateList)//ÏÉÆ·½±ÀøÁì½±¼Ç¼£¬°´µÈ¼¶¶þ½øÖÆλ´æ´¢ÊÇ·ñÁì½±
    StartTime = 0    #(DWORD StartTime)//ͨÌìÁî±¾ÂÖ¿ªÊ¼Ê±¼ä´Á£¬Ãë
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x56
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TTLBuyState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TTLLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CurPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardStateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardStateCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.CommAwardStateList.append(value)
        for i in range(self.AwardStateCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.XianAwardStateList.append(value)
        self.StartTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x56
        self.TTLBuyState = 0
        self.TTLLV = 0
        self.CurPoint = 0
        self.AwardStateCount = 0
        self.CommAwardStateList = list()
        self.XianAwardStateList = list()
        self.StartTime = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4
        length += 1
        length += 4 * self.AwardStateCount
        length += 4 * self.AwardStateCount
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TTLBuyState)
        data = CommFunc.WriteBYTE(data, self.TTLLV)
        data = CommFunc.WriteDWORD(data, self.CurPoint)
        data = CommFunc.WriteBYTE(data, self.AwardStateCount)
        for i in range(self.AwardStateCount):
            data = CommFunc.WriteDWORD(data, self.CommAwardStateList[i])
        for i in range(self.AwardStateCount):
            data = CommFunc.WriteDWORD(data, self.XianAwardStateList[i])
        data = CommFunc.WriteDWORD(data, self.StartTime)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TTLBuyState:%d,
                                TTLLV:%d,
                                CurPoint:%d,
                                AwardStateCount:%d,
                                CommAwardStateList:%s,
                                XianAwardStateList:%s,
                                StartTime:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TTLBuyState,
                                self.TTLLV,
                                self.CurPoint,
                                self.AwardStateCount,
                                "...",
                                "...",
                                self.StartTime
                                )
        return DumpString


m_NAtagMCTongTianLingInfo=tagMCTongTianLingInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTongTianLingInfo.Head.Cmd,m_NAtagMCTongTianLingInfo.Head.SubCmd))] = m_NAtagMCTongTianLingInfo


#------------------------------------------------------
# A3 58 ͨÌìÁîÈÎÎñ½±ÀøÐÅÏ¢ #tagMCTongTianLingTaskAwardInfo

class  tagMCTongTianLingTaskAwardInfo(Structure):
    Head = tagHead()
    AwardStateCount = 0    #(BYTE AwardStateCount)
    TaskAwardStateList = list()    #(vector<DWORD> TaskAwardStateList)//ÈÎÎñÁì½±¼Ç¼ֵ¸öÊý£¬°´ÈÎÎñID¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡£¬Ã¿¸öÖµ´æ31¸ö¼Ç¼   0-30, 31-61, ...
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x58
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AwardStateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardStateCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TaskAwardStateList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x58
        self.AwardStateCount = 0
        self.TaskAwardStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.AwardStateCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.AwardStateCount)
        for i in range(self.AwardStateCount):
            data = CommFunc.WriteDWORD(data, self.TaskAwardStateList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AwardStateCount:%d,
                                TaskAwardStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AwardStateCount,
                                "..."
                                )
        return DumpString


m_NAtagMCTongTianLingTaskAwardInfo=tagMCTongTianLingTaskAwardInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTongTianLingTaskAwardInfo.Head.Cmd,m_NAtagMCTongTianLingTaskAwardInfo.Head.SubCmd))] = m_NAtagMCTongTianLingTaskAwardInfo


#------------------------------------------------------
# A3 57 ͨÌìÁîÈÎÎñ½ø¶ÈÐÅÏ¢ #tagMCTongTianLingTaskValueInfo

class  tagMCTongTianLingTaskValue(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TaskType", c_ubyte),    #³É¾ÍÀàÐÍ
                  ("IsDaily", c_ubyte),    #ÊÇ·ñÿÈÕÈÎÎñ
                  ("TaskValue", c_int),    #µ±Ç°Íê³É½ø¶ÈÖµ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.TaskType = 0
        self.IsDaily = 0
        self.TaskValue = 0
        return

    def GetLength(self):
        return sizeof(tagMCTongTianLingTaskValue)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 57 ͨÌìÁîÈÎÎñ½ø¶ÈÐÅÏ¢ //tagMCTongTianLingTaskValueInfo:
                                TaskType:%d,
                                IsDaily:%d,
                                TaskValue:%d
                                '''\
                                %(
                                self.TaskType,
                                self.IsDaily,
                                self.TaskValue
                                )
        return DumpString


class  tagMCTongTianLingTaskValueInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)//ÐÅÏ¢¸öÊý
    TaskValueList = list()    #(vector<tagMCTongTianLingTaskValue> TaskValueList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x57
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temTaskValueList = tagMCTongTianLingTaskValue()
            _pos = temTaskValueList.ReadData(_lpData, _pos)
            self.TaskValueList.append(temTaskValueList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x57
        self.Count = 0
        self.TaskValueList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.TaskValueList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.TaskValueList[i].GetLength(), self.TaskValueList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                TaskValueList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCTongTianLingTaskValueInfo=tagMCTongTianLingTaskValueInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTongTianLingTaskValueInfo.Head.Cmd,m_NAtagMCTongTianLingTaskValueInfo.Head.SubCmd))] = m_NAtagMCTongTianLingTaskValueInfo


#------------------------------------------------------
#A3 01 ×øÆïÅàÑøÐÅÏ¢ #tagTrainHorseData

class  tagTrainHorseData(Structure):
    Head = tagHead()
    LV = 0    #(BYTE LV)//µÈ½×
    EatItemCount = 0    #(DWORD EatItemCount)//µ±Ç°½×ÒѳԵ¤¸öÊý
    SkinPlusState = 0    #(DWORD SkinPlusState)//»Ã»¯¼¤»î״̬£¬°´Î»´æ´¢ÊÇ·ñ¼¤»î£¬»Ã»¯±àºÅID¶ÔӦ룬·ÏÆú£¬Ê¹Óà SkinPlusStateList
    TrainTypes = 0    #(BYTE TrainTypes)//ÅàÑøÀàÐÍÊý
    TrainLVList = list()    #(vector<DWORD> TrainLVList)//ÅàÑøµÈ½×ÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    TrainItemCountList = list()    #(vector<DWORD> TrainItemCountList)//ÅàÑøµ±Ç°½×ÒѳÔÅàÑøµ¤¸öÊýÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    SkinPlusStateCount = 0    #(BYTE SkinPlusStateCount)//»Ã»¯¼¤»î״ֵ̬Êý
    SkinPlusStateList = list()    #(vector<DWORD> SkinPlusStateList)//»Ã»¯¼¤»î״ֵ̬ÁÐ±í£¬°´Î»´æ´¢ÊÇ·ñ¼¤»î£¬»Ã»¯±àºÅID¶ÔӦλ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x01
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.EatItemCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SkinPlusState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TrainTypes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainLVList.append(value)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainItemCountList.append(value)
        self.SkinPlusStateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SkinPlusStateCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.SkinPlusStateList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x01
        self.LV = 0
        self.EatItemCount = 0
        self.SkinPlusState = 0
        self.TrainTypes = 0
        self.TrainLVList = list()
        self.TrainItemCountList = list()
        self.SkinPlusStateCount = 0
        self.SkinPlusStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 4
        length += 1
        length += 4 * self.TrainTypes
        length += 4 * self.TrainTypes
        length += 1
        length += 4 * self.SkinPlusStateCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.EatItemCount)
        data = CommFunc.WriteDWORD(data, self.SkinPlusState)
        data = CommFunc.WriteBYTE(data, self.TrainTypes)
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainLVList[i])
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainItemCountList[i])
        data = CommFunc.WriteBYTE(data, self.SkinPlusStateCount)
        for i in range(self.SkinPlusStateCount):
            data = CommFunc.WriteDWORD(data, self.SkinPlusStateList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                LV:%d,
                                EatItemCount:%d,
                                SkinPlusState:%d,
                                TrainTypes:%d,
                                TrainLVList:%s,
                                TrainItemCountList:%s,
                                SkinPlusStateCount:%d,
                                SkinPlusStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.LV,
                                self.EatItemCount,
                                self.SkinPlusState,
                                self.TrainTypes,
                                "...",
                                "...",
                                self.SkinPlusStateCount,
                                "..."
                                )
        return DumpString


m_NAtagTrainHorseData=tagTrainHorseData()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagTrainHorseData.Head.Cmd,m_NAtagTrainHorseData.Head.SubCmd))] = m_NAtagTrainHorseData


#------------------------------------------------------
# A3 51 Ñ°±¦¹¦ÄÜÐÅÏ¢ #tagMCTreasureInfo

class  tagMCTreasureGridLimit(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GridNum", c_ubyte),    # ÓÐÏÞÖƳéÈ¡´ÎÊýµÄ¸ñ×Ó±àºÅ
                  ("GridCnt", 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.GridNum = 0
        self.GridCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCTreasureGridLimit)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 51 Ñ°±¦¹¦ÄÜÐÅÏ¢ //tagMCTreasureInfo:
                                GridNum:%d,
                                GridCnt:%d
                                '''\
                                %(
                                self.GridNum,
                                self.GridCnt
                                )
        return DumpString


class  tagMCTreasureTypeInfo(Structure):
    TreasureType = 0    #(BYTE TreasureType)//Ñ°±¦ÀàÐÍ
    LuckValue = 0    #(WORD LuckValue)//µ±Ç°ÐÒÔËÖµ
    TreasureCount = 0    #(DWORD TreasureCount)//ÒÑÑ°±¦×Ü´ÎÊý
    FreeCountToday = 0    #(WORD FreeCountToday)//½ñÈÕÒÑÃâ·ÑÑ°±¦´ÎÊý
    TreasureCntAward = 0    #(DWORD TreasureCntAward)//ÀÛ¼ÆÑ°±¦´ÎÊý¶ÔÓ¦½±ÀøÁ콱״̬£¬°´½±Àø¼Ç¼Ë÷Òý¶þ½øÖƼǼÊÇ·ñÒÑÁìÈ¡
    GridLimitCnt = 0    #(BYTE GridLimitCnt)
    GridLimitCntList = list()    #(vector<tagMCTreasureGridLimit> GridLimitCntList)//ÓÐÏÞÖƳéÈ¡´ÎÊýµÄ¸ñ×Ó´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TreasureType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LuckValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TreasureCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FreeCountToday,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TreasureCntAward,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GridLimitCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GridLimitCnt):
            temGridLimitCntList = tagMCTreasureGridLimit()
            _pos = temGridLimitCntList.ReadData(_lpData, _pos)
            self.GridLimitCntList.append(temGridLimitCntList)
        return _pos

    def Clear(self):
        self.TreasureType = 0
        self.LuckValue = 0
        self.TreasureCount = 0
        self.FreeCountToday = 0
        self.TreasureCntAward = 0
        self.GridLimitCnt = 0
        self.GridLimitCntList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 4
        length += 2
        length += 4
        length += 1
        for i in range(self.GridLimitCnt):
            length += self.GridLimitCntList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.TreasureType)
        data = CommFunc.WriteWORD(data, self.LuckValue)
        data = CommFunc.WriteDWORD(data, self.TreasureCount)
        data = CommFunc.WriteWORD(data, self.FreeCountToday)
        data = CommFunc.WriteDWORD(data, self.TreasureCntAward)
        data = CommFunc.WriteBYTE(data, self.GridLimitCnt)
        for i in range(self.GridLimitCnt):
            data = CommFunc.WriteString(data, self.GridLimitCntList[i].GetLength(), self.GridLimitCntList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TreasureType:%d,
                                LuckValue:%d,
                                TreasureCount:%d,
                                FreeCountToday:%d,
                                TreasureCntAward:%d,
                                GridLimitCnt:%d,
                                GridLimitCntList:%s
                                '''\
                                %(
                                self.TreasureType,
                                self.LuckValue,
                                self.TreasureCount,
                                self.FreeCountToday,
                                self.TreasureCntAward,
                                self.GridLimitCnt,
                                "..."
                                )
        return DumpString


class  tagMCTreasureInfo(Structure):
    Head = tagHead()
    InfoCount = 0    #(BYTE InfoCount)// Ñ°±¦ÀàÐÍÐÅÏ¢Êý
    TreasuerInfoList = list()    #(vector<tagMCTreasureTypeInfo> TreasuerInfoList)// Ñ°±¦ÀàÐÍÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x51
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.InfoCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.InfoCount):
            temTreasuerInfoList = tagMCTreasureTypeInfo()
            _pos = temTreasuerInfoList.ReadData(_lpData, _pos)
            self.TreasuerInfoList.append(temTreasuerInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x51
        self.InfoCount = 0
        self.TreasuerInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.InfoCount):
            length += self.TreasuerInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.InfoCount)
        for i in range(self.InfoCount):
            data = CommFunc.WriteString(data, self.TreasuerInfoList[i].GetLength(), self.TreasuerInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                InfoCount:%d,
                                TreasuerInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.InfoCount,
                                "..."
                                )
        return DumpString


m_NAtagMCTreasureInfo=tagMCTreasureInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTreasureInfo.Head.Cmd,m_NAtagMCTreasureInfo.Head.SubCmd))] = m_NAtagMCTreasureInfo


#------------------------------------------------------
# A3 50 ֪ͨѰ±¦½á¹û #tagMCTreasureResult

class  tagMCTreasureResult(Structure):
    Head = tagHead()
    AddMoneyType = 0    #(BYTE AddMoneyType)// ±¾´ÎÑ°±¦Ôö¼ÓµÄ»ý·Ö»õ±ÒÀàÐÍ£¬¿ÉÄÜΪ0
    AddMoneyValue = 0    #(WORD AddMoneyValue)// ±¾´ÎÑ°±¦Ôö¼ÓµÄ»ý·Ö»õ±ÒÖµ£¬¿ÉÄÜΪ0
    AddTreasureLuck = 0    #(WORD AddTreasureLuck)// ±¾´ÎÑ°±¦Ôö¼ÓµÄÐÒÔËÖµ
    TreasureResultLen = 0    #(WORD TreasureResultLen)
    TreasureResult = ""    #(String TreasureResult)//  »ñµÃÎïÆ·½á¹û[[¸ñ×Ó±àºÅ, ÎïÆ·ID,¸öÊý,ÊÇ·ñ°ó¶¨], ...]
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x50
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AddMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AddMoneyValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AddTreasureLuck,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TreasureResultLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TreasureResult,_pos = CommFunc.ReadString(_lpData, _pos,self.TreasureResultLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x50
        self.AddMoneyType = 0
        self.AddMoneyValue = 0
        self.AddTreasureLuck = 0
        self.TreasureResultLen = 0
        self.TreasureResult = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 2
        length += 2
        length += 2
        length += len(self.TreasureResult)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.AddMoneyType)
        data = CommFunc.WriteWORD(data, self.AddMoneyValue)
        data = CommFunc.WriteWORD(data, self.AddTreasureLuck)
        data = CommFunc.WriteWORD(data, self.TreasureResultLen)
        data = CommFunc.WriteString(data, self.TreasureResultLen, self.TreasureResult)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AddMoneyType:%d,
                                AddMoneyValue:%d,
                                AddTreasureLuck:%d,
                                TreasureResultLen:%d,
                                TreasureResult:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AddMoneyType,
                                self.AddMoneyValue,
                                self.AddTreasureLuck,
                                self.TreasureResultLen,
                                self.TreasureResult
                                )
        return DumpString


m_NAtagMCTreasureResult=tagMCTreasureResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTreasureResult.Head.Cmd,m_NAtagMCTreasureResult.Head.SubCmd))] = m_NAtagMCTreasureResult


#------------------------------------------------------
# A3 BA ֪ͨÊÔÁ¶Ö®Ëþ¹ý¹ØÊý #tagMCTrialTowerInfo

class  tagMCTrialTowerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PassLV", c_int),    
                  ("YesterDayPassLV", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0xBA
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0xBA
        self.PassLV = 0
        self.YesterDayPassLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCTrialTowerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 BA ֪ͨÊÔÁ¶Ö®Ëþ¹ý¹ØÊý //tagMCTrialTowerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                PassLV:%d,
                                YesterDayPassLV:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PassLV,
                                self.YesterDayPassLV
                                )
        return DumpString


m_NAtagMCTrialTowerInfo=tagMCTrialTowerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTrialTowerInfo.Cmd,m_NAtagMCTrialTowerInfo.SubCmd))] = m_NAtagMCTrialTowerInfo


#------------------------------------------------------
#A3 05 ɨµ´½±ÀøÐÅÏ¢ #tagMCWipeOutPrize

class  tagMCPrizeItemInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ItemID", c_int),    #ÎïÆ·id
                  ("ItemCnt", c_ubyte),    #ÎïÆ·ÊýÁ¿
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x05
        self.ItemID = 0
        self.ItemCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCPrizeItemInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A3 05 ɨµ´½±ÀøÐÅÏ¢ //tagMCWipeOutPrize:
                                Cmd:%s,
                                SubCmd:%s,
                                ItemID:%d,
                                ItemCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ItemID,
                                self.ItemCnt
                                )
        return DumpString


class  tagMCWipeOutPrize(Structure):
    Head = tagHead()
    FBID = 0    #(DWORD FBID)//¸±±¾id
    WipeOutCnt = 0    #(DWORD WipeOutCnt)//ɨµ´´ÎÊý
    GiveExp = 0    #(DWORD GiveExp)//¸øÓè¾­Ñé
    SilverCnt = 0    #(DWORD SilverCnt)//¸øÓè½ð±Ò
    PrizeCnt = 0    #(BYTE PrizeCnt)//״̬
    PrizeInfo = list()    #(vector<tagMCPrizeItemInfo> PrizeInfo)//״̬
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x05
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WipeOutCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiveExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SilverCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PrizeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PrizeCnt):
            temPrizeInfo = tagMCPrizeItemInfo()
            _pos = temPrizeInfo.ReadData(_lpData, _pos)
            self.PrizeInfo.append(temPrizeInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x05
        self.FBID = 0
        self.WipeOutCnt = 0
        self.GiveExp = 0
        self.SilverCnt = 0
        self.PrizeCnt = 0
        self.PrizeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        for i in range(self.PrizeCnt):
            length += self.PrizeInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.FBID)
        data = CommFunc.WriteDWORD(data, self.WipeOutCnt)
        data = CommFunc.WriteDWORD(data, self.GiveExp)
        data = CommFunc.WriteDWORD(data, self.SilverCnt)
        data = CommFunc.WriteBYTE(data, self.PrizeCnt)
        for i in range(self.PrizeCnt):
            data = CommFunc.WriteString(data, self.PrizeInfo[i].GetLength(), self.PrizeInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FBID:%d,
                                WipeOutCnt:%d,
                                GiveExp:%d,
                                SilverCnt:%d,
                                PrizeCnt:%d,
                                PrizeInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FBID,
                                self.WipeOutCnt,
                                self.GiveExp,
                                self.SilverCnt,
                                self.PrizeCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCWipeOutPrize=tagMCWipeOutPrize()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCWipeOutPrize.Head.Cmd,m_NAtagMCWipeOutPrize.Head.SubCmd))] = m_NAtagMCWipeOutPrize


#------------------------------------------------------
# A3 35 ֪ͨÊÀ½çµÈ¼¶ #tagPyMCWorldAverageLv

class  tagPyMCWorldAverageLv(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("WorldLv", c_ushort),    #µ±Ç°ÊÀ½çµÈ¼¶
                  ("ExpRate", c_int),    #ÊÀ½çµÈ¼¶¾­Ñ鱶ÂÊ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA3
        self.SubCmd = 0x35
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA3
        self.SubCmd = 0x35
        self.WorldLv = 0
        self.ExpRate = 0
        return

    def GetLength(self):
        return sizeof(tagPyMCWorldAverageLv)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 35 ֪ͨÊÀ½çµÈ¼¶ //tagPyMCWorldAverageLv:
                                Cmd:%s,
                                SubCmd:%s,
                                WorldLv:%d,
                                ExpRate:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.WorldLv,
                                self.ExpRate
                                )
        return DumpString


m_NAtagPyMCWorldAverageLv=tagPyMCWorldAverageLv()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagPyMCWorldAverageLv.Cmd,m_NAtagPyMCWorldAverageLv.SubCmd))] = m_NAtagPyMCWorldAverageLv


#------------------------------------------------------
# A3 48 Ïɱ¦Ñ°Ö÷Áì½±¼Ç¼ #tagMCXBXZAwardRecordList

class  tagMCXBXZAwardRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RecordIndex", c_ushort),    #µÚ¼¸¸ö¼Ç¼ֵ ÿ¸ökey´æ31¸öid   0-30Ϊ0, 31-61Ϊ1..
                  ("Record", 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.RecordIndex = 0
        self.Record = 0
        return

    def GetLength(self):
        return sizeof(tagMCXBXZAwardRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A3 48 Ïɱ¦Ñ°Ö÷Áì½±¼Ç¼ //tagMCXBXZAwardRecordList:
                                RecordIndex:%d,
                                Record:%d
                                '''\
                                %(
                                self.RecordIndex,
                                self.Record
                                )
        return DumpString


class  tagMCXBXZAwardRecordList(Structure):
    Head = tagHead()
    RecordCnt = 0    #(WORD RecordCnt)//¼Ç¼¸öÊý
    RecordList = list()    #(vector<tagMCXBXZAwardRecord> RecordList)//¼Ç¼Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x48
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RecordCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RecordCnt):
            temRecordList = tagMCXBXZAwardRecord()
            _pos = temRecordList.ReadData(_lpData, _pos)
            self.RecordList.append(temRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA3
        self.Head.SubCmd = 0x48
        self.RecordCnt = 0
        self.RecordList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.RecordCnt):
            length += self.RecordList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RecordCnt)
        for i in range(self.RecordCnt):
            data = CommFunc.WriteString(data, self.RecordList[i].GetLength(), self.RecordList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RecordCnt:%d,
                                RecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RecordCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCXBXZAwardRecordList=tagMCXBXZAwardRecordList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCXBXZAwardRecordList.Head.Cmd,m_NAtagMCXBXZAwardRecordList.Head.SubCmd))] = m_NAtagMCXBXZAwardRecordList


#------------------------------------------------------
# A5 35 ÍõÕßÏÉÃËÿÈÕٺ»½±Àø״̬ #tagMCChampionFamilyDailyReward

class  tagMCChampionFamilyDailyReward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GetState", c_ubyte),    #ÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x35
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x35
        self.GetState = 0
        return

    def GetLength(self):
        return sizeof(tagMCChampionFamilyDailyReward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 35 ÍõÕßÏÉÃËÿÈÕٺ»½±Àø״̬ //tagMCChampionFamilyDailyReward:
                                Cmd:%s,
                                SubCmd:%s,
                                GetState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GetState
                                )
        return DumpString


m_NAtagMCChampionFamilyDailyReward=tagMCChampionFamilyDailyReward()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChampionFamilyDailyReward.Cmd,m_NAtagMCChampionFamilyDailyReward.SubCmd))] = m_NAtagMCChampionFamilyDailyReward


#------------------------------------------------------
# A5 10 ´«¹¦½±Àø½á¹û #tagMCChuangongResult

class  tagMCChuangongItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", 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.ItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCChuangongItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 10 ´«¹¦½±Àø½á¹û //tagMCChuangongResult:
                                ItemID:%d,
                                ItemCount:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount
                                )
        return DumpString


class  tagMCChuangongResult(Structure):
    Head = tagHead()
    FromLV = 0    #(WORD FromLV)// ´«¹¦Ç°µÈ¼¶
    ToLV = 0    #(WORD ToLV)// ´«¹¦ºóµÈ¼¶
    Exp = 0    #(DWORD Exp)// »ñµÃ¾­ÑéÇóÓàÒÚ²¿·Ö
    ExpPoint = 0    #(DWORD ExpPoint)// »ñµÃ¾­ÑéÕû³ýÒÚ²¿·Ö
    ItemCount = 0    #(BYTE ItemCount)
    AwardItemList = list()    #(vector<tagMCChuangongItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x10
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FromLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ToLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Exp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ItemCount):
            temAwardItemList = tagMCChuangongItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x10
        self.FromLV = 0
        self.ToLV = 0
        self.Exp = 0
        self.ExpPoint = 0
        self.ItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 2
        length += 4
        length += 4
        length += 1
        for i in range(self.ItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.FromLV)
        data = CommFunc.WriteWORD(data, self.ToLV)
        data = CommFunc.WriteDWORD(data, self.Exp)
        data = CommFunc.WriteDWORD(data, self.ExpPoint)
        data = CommFunc.WriteBYTE(data, self.ItemCount)
        for i in range(self.ItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FromLV:%d,
                                ToLV:%d,
                                Exp:%d,
                                ExpPoint:%d,
                                ItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FromLV,
                                self.ToLV,
                                self.Exp,
                                self.ExpPoint,
                                self.ItemCount,
                                "..."
                                )
        return DumpString


m_NAtagMCChuangongResult=tagMCChuangongResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChuangongResult.Head.Cmd,m_NAtagMCChuangongResult.Head.SubCmd))] = m_NAtagMCChuangongResult


#------------------------------------------------------
# A5 02 ¼Ò×å»îÔ¾Áî¶Ò»»½á¹û #tagMCFamilyActivityExchangeResult

class  tagMCFamilyActivityExchangeResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Point", c_int),    # »îÔ¾Áî
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x02
        self.Point = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyActivityExchangeResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 02 ¼Ò×å»îÔ¾Áî¶Ò»»½á¹û //tagMCFamilyActivityExchangeResult:
                                Cmd:%s,
                                SubCmd:%s,
                                Point:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Point
                                )
        return DumpString


m_NAtagMCFamilyActivityExchangeResult=tagMCFamilyActivityExchangeResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyActivityExchangeResult.Cmd,m_NAtagMCFamilyActivityExchangeResult.SubCmd))] = m_NAtagMCFamilyActivityExchangeResult


#------------------------------------------------------
# A5 08 ¼Ò×åÊÂÎñÐÅÏ¢ #tagMCFamilyAffairInfo

class  tagMCFamilyAffair(Structure):
    _pack_ = 1
    _fields_ = [
                  ("AffairID", c_ushort),    # ÊÂÎñID
                  ("Star", c_ubyte),    # ÐǼ¶
                  ("State", c_ubyte),    # ״̬£º0-ÎÞ£»1-½øÐÐÖУ»2-ÒÑÍê³É
                  ("RemainDuration", c_ushort),    # Ê£Óàʱ³¤£¬Ã룬ÓÐÊ£Óàʱ¼ä´ú±í½øÐÐÖÐ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.AffairID = 0
        self.Star = 0
        self.State = 0
        self.RemainDuration = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyAffair)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 08 ¼Ò×åÊÂÎñÐÅÏ¢ //tagMCFamilyAffairInfo:
                                AffairID:%d,
                                Star:%d,
                                State:%d,
                                RemainDuration:%d
                                '''\
                                %(
                                self.AffairID,
                                self.Star,
                                self.State,
                                self.RemainDuration
                                )
        return DumpString


class  tagMCFamilyAffairInfo(Structure):
    Head = tagHead()
    RefreshFreeCount = 0    #(BYTE RefreshFreeCount)// ½ñÈÕÒÑÃâ·ÑˢдÎÊý
    Count = 0    #(BYTE Count)
    AffairInfoList = list()    #(vector<tagMCFamilyAffair> AffairInfoList)// ÊÂÎñÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x08
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RefreshFreeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAffairInfoList = tagMCFamilyAffair()
            _pos = temAffairInfoList.ReadData(_lpData, _pos)
            self.AffairInfoList.append(temAffairInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x08
        self.RefreshFreeCount = 0
        self.Count = 0
        self.AffairInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.AffairInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.RefreshFreeCount)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AffairInfoList[i].GetLength(), self.AffairInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RefreshFreeCount:%d,
                                Count:%d,
                                AffairInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RefreshFreeCount,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFamilyAffairInfo=tagMCFamilyAffairInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyAffairInfo.Head.Cmd,m_NAtagMCFamilyAffairInfo.Head.SubCmd))] = m_NAtagMCFamilyAffairInfo


#------------------------------------------------------
# A5 07 ¼Ò×åboss¸±±¾Íæ¼ÒÐÅÏ¢ #tagMCFamilyBosFBPlayerInfo

class  tagMCFamilyBosFBPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("HurtTotal", c_int),    # ÀÛ¼ÆÉËѪ£¬ÒÚÇóÓಿ·Ö
                  ("HurtTotalPoint", c_int),    # ÀÛ¼ÆÉËѪ£¬ÒÚÕû³ý²¿·Ö
                  ("FightSeconds", c_int),    # ÒÑÀÛ¼ÆÕ½¶·Ê±³¤£¬Ãë
                  ("HurtAwardState", c_int),    # ¸öÈË×ÜÉËѪÁì½±¼Ç¼£¬°´½±Àøλ¶þ½øÖÆλÔËËã±íʾÊÇ·ñÒÑÁìÈ¡
                  ("HurtAwardStateFamily", c_int),    # ÏÉÃË×ÜÉËѪÁì½±¼Ç¼£¬°´½±Àøλ¶þ½øÖÆλÔËËã±íʾÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x07
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x07
        self.HurtTotal = 0
        self.HurtTotalPoint = 0
        self.FightSeconds = 0
        self.HurtAwardState = 0
        self.HurtAwardStateFamily = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyBosFBPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 07 ¼Ò×åboss¸±±¾Íæ¼ÒÐÅÏ¢ //tagMCFamilyBosFBPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                HurtTotal:%d,
                                HurtTotalPoint:%d,
                                FightSeconds:%d,
                                HurtAwardState:%d,
                                HurtAwardStateFamily:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.HurtTotal,
                                self.HurtTotalPoint,
                                self.FightSeconds,
                                self.HurtAwardState,
                                self.HurtAwardStateFamily
                                )
        return DumpString


m_NAtagMCFamilyBosFBPlayerInfo=tagMCFamilyBosFBPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyBosFBPlayerInfo.Cmd,m_NAtagMCFamilyBosFBPlayerInfo.SubCmd))] = m_NAtagMCFamilyBosFBPlayerInfo


#------------------------------------------------------
# A5 06 ÏÉÃËÿÈÕ¸£ÀûÁìȡ״̬ #tagMCFamilyDayAward

class  tagMCFamilyDayAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GetState", c_ubyte),    #ÊÇ·ñÒÑÁìÈ¡
                  ("MoneyDonateCount", c_ubyte),    #½ñÈÕ»õ±Ò¾èÏ×´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x06
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x06
        self.GetState = 0
        self.MoneyDonateCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyDayAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 06 ÏÉÃËÿÈÕ¸£ÀûÁìȡ״̬ //tagMCFamilyDayAward:
                                Cmd:%s,
                                SubCmd:%s,
                                GetState:%d,
                                MoneyDonateCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GetState,
                                self.MoneyDonateCount
                                )
        return DumpString


m_NAtagMCFamilyDayAward=tagMCFamilyDayAward()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyDayAward.Cmd,m_NAtagMCFamilyDayAward.SubCmd))] = m_NAtagMCFamilyDayAward


#------------------------------------------------------
# A5 03 µ±ÈÕÆí¸£ÐÅÏ¢ #tagMCFamilyPrayInfo

class  tagMCFamilyPrayInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PrayCntInfo", c_int),    # µ±ÈÕÆí¸£´ÎÊýÐÅÏ¢, °´Î»´æ´¢Æí¸£ÀàÐͶÔÓ¦´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x03
        self.PrayCntInfo = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyPrayInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 03 µ±ÈÕÆí¸£ÐÅÏ¢ //tagMCFamilyPrayInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                PrayCntInfo:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PrayCntInfo
                                )
        return DumpString


m_NAtagMCFamilyPrayInfo=tagMCFamilyPrayInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyPrayInfo.Cmd,m_NAtagMCFamilyPrayInfo.SubCmd))] = m_NAtagMCFamilyPrayInfo


#------------------------------------------------------
# A5 05 ֪ͨ¼Ò×å×êʯºì°üÒÑÓöî¶È #tagMCFamilyRedPacketGoldLimit

class  tagMCFamilyRedPacketGoldLimit(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("HasSendGold", c_int),    # ÒÑÓöî¶È
                  ("ServerGrabCnt", c_int),    # È«·þºì°üÒÑÇÀ´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x05
        self.HasSendGold = 0
        self.ServerGrabCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyRedPacketGoldLimit)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 05 ֪ͨ¼Ò×å×êʯºì°üÒÑÓöî¶È //tagMCFamilyRedPacketGoldLimit:
                                Cmd:%s,
                                SubCmd:%s,
                                HasSendGold:%d,
                                ServerGrabCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.HasSendGold,
                                self.ServerGrabCnt
                                )
        return DumpString


m_NAtagMCFamilyRedPacketGoldLimit=tagMCFamilyRedPacketGoldLimit()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyRedPacketGoldLimit.Cmd,m_NAtagMCFamilyRedPacketGoldLimit.SubCmd))] = m_NAtagMCFamilyRedPacketGoldLimit


#------------------------------------------------------
# A5 11 ´ò×øÐÅÏ¢ #tagMCFamilySitInfo

class  tagMCFamilySitInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ExpRound", c_ushort),    # ÒÑ»ñµÃ¾­ÑéÂÖ´Î
                  ("Exp", c_int),    # »ñµÃ¾­ÑéÇóÓàÒÚ²¿·Ö
                  ("ExpPoint", c_int),    # »ñµÃ¾­ÑéÕû³ýÒÚ²¿·Ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x11
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x11
        self.ExpRound = 0
        self.Exp = 0
        self.ExpPoint = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilySitInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 11 ´ò×øÐÅÏ¢ //tagMCFamilySitInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ExpRound:%d,
                                Exp:%d,
                                ExpPoint:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ExpRound,
                                self.Exp,
                                self.ExpPoint
                                )
        return DumpString


m_NAtagMCFamilySitInfo=tagMCFamilySitInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilySitInfo.Cmd,m_NAtagMCFamilySitInfo.SubCmd))] = m_NAtagMCFamilySitInfo


#------------------------------------------------------
# A5 12 Õ䱦¸óÐÅÏ¢ #tagMCFamilyZhenbaogeInfo

class  tagMCFamilyZhenbaogeInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CutState", c_ubyte),    # ½ñÈÕÊÇ·ñÒÑ¿³¼Û£¬´Ë״̬Ϊȫ¾Ö״̬£¬ÓëÃËAction¿³¼Û״̬²»Í¬
                  ("BuyState", c_ubyte),    # ½ñÈÕÊÇ·ñÒѹºÂò£¬´Ë״̬Ϊȫ¾Ö״̬£¬ÓëÃËAction¹ºÂò״̬²»Í¬
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA5
        self.SubCmd = 0x12
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA5
        self.SubCmd = 0x12
        self.CutState = 0
        self.BuyState = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyZhenbaogeInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 12 Õ䱦¸óÐÅÏ¢ //tagMCFamilyZhenbaogeInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                CutState:%d,
                                BuyState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CutState,
                                self.BuyState
                                )
        return DumpString


m_NAtagMCFamilyZhenbaogeInfo=tagMCFamilyZhenbaogeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyZhenbaogeInfo.Cmd,m_NAtagMCFamilyZhenbaogeInfo.SubCmd))] = m_NAtagMCFamilyZhenbaogeInfo


#------------------------------------------------------
# A5 09 ÏÉÃËÕó·¨ÐÅÏ¢ #tagMCFamilyZhenfaInfo

class  tagMCFamilyZhenfa(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ZhenfaType", c_ubyte),    # Õó·¨ÀàÐÍ
                  ("ZhenfaLV", c_ushort),    # Õ󷨵ȼ¶
                  ("ZhenfaExp", 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.ZhenfaType = 0
        self.ZhenfaLV = 0
        self.ZhenfaExp = 0
        return

    def GetLength(self):
        return sizeof(tagMCFamilyZhenfa)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 09 ÏÉÃËÕó·¨ÐÅÏ¢ //tagMCFamilyZhenfaInfo:
                                ZhenfaType:%d,
                                ZhenfaLV:%d,
                                ZhenfaExp:%d
                                '''\
                                %(
                                self.ZhenfaType,
                                self.ZhenfaLV,
                                self.ZhenfaExp
                                )
        return DumpString


class  tagMCFamilyZhenfaInfo(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// µ±Ç°ÅàÑøÕ󷨵ÄÍæ¼ÒID£¬Èç¹ûÓÐ×ö×Ô¶¯¾èÏ×£¬ÐèµÈÊÕµ½µÄÍæ¼ÒIDΪ×Ô¼ºµÄʱºò²Å·¢ËÍÏÂÒ»¸ö¾èÏ×°ü
    Count = 0    #(BYTE Count)
    ZhenfaInfoList = list()    #(vector<tagMCFamilyZhenfa> ZhenfaInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x09
        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.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temZhenfaInfoList = tagMCFamilyZhenfa()
            _pos = temZhenfaInfoList.ReadData(_lpData, _pos)
            self.ZhenfaInfoList.append(temZhenfaInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x09
        self.PlayerID = 0
        self.Count = 0
        self.ZhenfaInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.ZhenfaInfoList[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.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ZhenfaInfoList[i].GetLength(), self.ZhenfaInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                Count:%d,
                                ZhenfaInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFamilyZhenfaInfo=tagMCFamilyZhenfaInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyZhenfaInfo.Head.Cmd,m_NAtagMCFamilyZhenfaInfo.Head.SubCmd))] = m_NAtagMCFamilyZhenfaInfo


#------------------------------------------------------
#A5 01  ²é¿´ÒÑÉêÇë¼ÓÈëµÄ¼Ò×åÐÅÏ¢  #tagMCNotifyRequestJoinFamilyInfo

class  tagRequestJoinFamily(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RequestFamilyID", c_int),    #ÉêÇëµÄ¼ÓÈëID
                  ]

    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.RequestFamilyID = 0
        return

    def GetLength(self):
        return sizeof(tagRequestJoinFamily)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A5 01  ²é¿´ÒÑÉêÇë¼ÓÈëµÄ¼Ò×åÐÅÏ¢  //tagMCNotifyRequestJoinFamilyInfo:
                                RequestFamilyID:%d
                                '''\
                                %(
                                self.RequestFamilyID
                                )
        return DumpString


class  tagMCNotifyRequestJoinFamilyInfo(Structure):
    Head = tagHead()
    RequestCount = 0    #(BYTE RequestCount)//ÉêÇëµÄÊýÁ¿
    RequestAddFamilyInfo = list()    #(vector<tagRequestJoinFamily> RequestAddFamilyInfo)//size = RequestCount
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x01
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RequestCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RequestCount):
            temRequestAddFamilyInfo = tagRequestJoinFamily()
            _pos = temRequestAddFamilyInfo.ReadData(_lpData, _pos)
            self.RequestAddFamilyInfo.append(temRequestAddFamilyInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x01
        self.RequestCount = 0
        self.RequestAddFamilyInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.RequestCount):
            length += self.RequestAddFamilyInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.RequestCount)
        for i in range(self.RequestCount):
            data = CommFunc.WriteString(data, self.RequestAddFamilyInfo[i].GetLength(), self.RequestAddFamilyInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RequestCount:%d,
                                RequestAddFamilyInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RequestCount,
                                "..."
                                )
        return DumpString


m_NAtagMCNotifyRequestJoinFamilyInfo=tagMCNotifyRequestJoinFamilyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifyRequestJoinFamilyInfo.Head.Cmd,m_NAtagMCNotifyRequestJoinFamilyInfo.Head.SubCmd))] = m_NAtagMCNotifyRequestJoinFamilyInfo


#------------------------------------------------------
# A5 04 Íæ¼ÒÕ½Ã˿Ƽ¼µÈ¼¶ #tagMCPlayerTechInfo

class  tagMCPlayerTech(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TechID", c_ushort),    # ¿Æ¼¼ID
                  ("TechLV", c_ushort),    # Ìؼ¼µÈ¼¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.TechID = 0
        self.TechLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerTech)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A5 04 Íæ¼ÒÕ½Ã˿Ƽ¼µÈ¼¶ //tagMCPlayerTechInfo:
                                TechID:%d,
                                TechLV:%d
                                '''\
                                %(
                                self.TechID,
                                self.TechLV
                                )
        return DumpString


class  tagMCPlayerTechInfo(Structure):
    Head = tagHead()
    TechCnt = 0    #(BYTE TechCnt)// ¿Æ¼¼¸öÊý
    TechInfoList = list()    #(vector<tagMCPlayerTech> TechInfoList)// ¿Æ¼¼ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TechCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TechCnt):
            temTechInfoList = tagMCPlayerTech()
            _pos = temTechInfoList.ReadData(_lpData, _pos)
            self.TechInfoList.append(temTechInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA5
        self.Head.SubCmd = 0x04
        self.TechCnt = 0
        self.TechInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.TechCnt):
            length += self.TechInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TechCnt)
        for i in range(self.TechCnt):
            data = CommFunc.WriteString(data, self.TechInfoList[i].GetLength(), self.TechInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TechCnt:%d,
                                TechInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TechCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPlayerTechInfo=tagMCPlayerTechInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerTechInfo.Head.Cmd,m_NAtagMCPlayerTechInfo.Head.SubCmd))] = m_NAtagMCPlayerTechInfo


#------------------------------------------------------
# A6 05 VIPÀñ°ü¹ºÂò¼Ç¼ #tagMCVIPAwardMsg

class  tagMCVIPAwardMsg(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AwardMsg", c_int),    # VIPÀñ°ü¹ºÂò¼Ç¼
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA6
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA6
        self.SubCmd = 0x05
        self.AwardMsg = 0
        return

    def GetLength(self):
        return sizeof(tagMCVIPAwardMsg)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A6 05 VIPÀñ°ü¹ºÂò¼Ç¼ //tagMCVIPAwardMsg:
                                Cmd:%s,
                                SubCmd:%s,
                                AwardMsg:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AwardMsg
                                )
        return DumpString


m_NAtagMCVIPAwardMsg=tagMCVIPAwardMsg()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCVIPAwardMsg.Cmd,m_NAtagMCVIPAwardMsg.SubCmd))] = m_NAtagMCVIPAwardMsg


#------------------------------------------------------
# A6 03 ¹ó×åÐÅÏ¢ #tagMCNobleInfo

class  tagMCNobleInfo(Structure):
    Head = tagHead()
    LV = 0    #(BYTE LV)// ¹ó×åµÈ¼¶
    Time = 0    #(DWORD Time)// ¹ó×åʱ¼ä<µ¥Î»Ãë>
    NobleState = 0    #(DWORD NobleState)// ¹ó×忪ͨ״̬; µÚ0λΪ¾É°æµÄ¹ó×åµÈ¼¶, ´ÓµÚ1λ¿ªÊ¼±íʾÿÖÖ¹ó×åµÄ¿ªÍ¨×´Ì¬(0-δ¿ªÍ¨, 1-ÒÑ¿ªÍ¨¹ý, 9-ÓÀ¾ÃÓÐЧ )
    Count = 0    #(WORD Count)// ¹ó×åʱ¼ä¸öÊý
    NobleTimeList = list()    #(vector<DWORD> NobleTimeList)// ¹ó×åʱ¼äÁбí<µ¥Î»Ãë>
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA6
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NobleState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.NobleTimeList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA6
        self.Head.SubCmd = 0x03
        self.LV = 0
        self.Time = 0
        self.NobleState = 0
        self.Count = 0
        self.NobleTimeList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 4
        length += 2
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.Time)
        data = CommFunc.WriteDWORD(data, self.NobleState)
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.NobleTimeList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                LV:%d,
                                Time:%d,
                                NobleState:%d,
                                Count:%d,
                                NobleTimeList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.LV,
                                self.Time,
                                self.NobleState,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCNobleInfo=tagMCNobleInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNobleInfo.Head.Cmd,m_NAtagMCNobleInfo.Head.SubCmd))] = m_NAtagMCNobleInfo


#------------------------------------------------------
#A6 01 ֪ͨVIPʱ¼ä #tagMCNotifyVipTime

class  tagMCNotifyVipTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Time", c_int),    # VIPʱ¼ä£¬µ¥Î»Ãë
                  ("ExperienceTime", c_int),    # VIPÌåÑéʱ¼ä£¬µ¥Î»Ãë
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA6
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA6
        self.SubCmd = 0x01
        self.Time = 0
        self.ExperienceTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCNotifyVipTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A6 01 ֪ͨVIPʱ¼ä //tagMCNotifyVipTime:
                                Cmd:%s,
                                SubCmd:%s,
                                Time:%d,
                                ExperienceTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Time,
                                self.ExperienceTime
                                )
        return DumpString


m_NAtagMCNotifyVipTime=tagMCNotifyVipTime()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifyVipTime.Cmd,m_NAtagMCNotifyVipTime.SubCmd))] = m_NAtagMCNotifyVipTime


#------------------------------------------------------
# A6 04 VIPÐÅÏ¢ #tagMCVIPInfo

class  tagMCVIPInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Exp", c_int),    # µ±Ç°VIPµÈ¼¶¾­Ñé
                  ("VIPLV", c_int),    #vipµÈ¼¶ 
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA6
        self.SubCmd = 0x04
        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 = 0xA6
        self.SubCmd = 0x04
        self.Exp = 0
        self.VIPLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCVIPInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A6 04 VIPÐÅÏ¢ //tagMCVIPInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                Exp:%d,
                                VIPLV:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Exp,
                                self.VIPLV
                                )
        return DumpString


m_NAtagMCVIPInfo=tagMCVIPInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCVIPInfo.Cmd,m_NAtagMCVIPInfo.SubCmd))] = m_NAtagMCVIPInfo


#------------------------------------------------------
# A6 06 VIPɱ¹ÖµÈ¼¶ÐÅÏ¢ #tagMCVIPKillNPCLVInfo

class  tagMCVIPKillNPCLVInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("KillLV", c_ushort),    # µÈ¼¶
                  ("KillLVExpPoint", c_int),    # ¾­Ñéµã£¬1µã1ÒÚ
                  ("KillLVExp", c_int),    # δÂú1Òڵľ­Ñé
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA6
        self.SubCmd = 0x06
        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 = 0xA6
        self.SubCmd = 0x06
        self.KillLV = 0
        self.KillLVExpPoint = 0
        self.KillLVExp = 0
        return

    def GetLength(self):
        return sizeof(tagMCVIPKillNPCLVInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A6 06 VIPɱ¹ÖµÈ¼¶ÐÅÏ¢ //tagMCVIPKillNPCLVInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                KillLV:%d,
                                KillLVExpPoint:%d,
                                KillLVExp:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.KillLV,
                                self.KillLVExpPoint,
                                self.KillLVExp
                                )
        return DumpString


m_NAtagMCVIPKillNPCLVInfo=tagMCVIPKillNPCLVInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCVIPKillNPCLVInfo.Cmd,m_NAtagMCVIPKillNPCLVInfo.SubCmd))] = m_NAtagMCVIPKillNPCLVInfo


#------------------------------------------------------
# A7 04 ֪ͨÊÀ½çBossÉËѪÁбí #tagMCBossHurtList

class  tagMCHurtPlayer(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)// ÉËѪÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    PlayerName = ""    #(String PlayerName)
    HurtValue = 0    #(DWORD HurtValue)// ÀÛ¼ÆÉËѪ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x04
        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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.HurtValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x04
        self.PlayerID = 0
        self.NameLen = 0
        self.PlayerName = ""
        self.HurtValue = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += len(self.PlayerName)
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
        data = CommFunc.WriteDWORD(data, self.HurtValue)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                NameLen:%d,
                                PlayerName:%s,
                                HurtValue:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.NameLen,
                                self.PlayerName,
                                self.HurtValue
                                )
        return DumpString


class  tagMCBossHurtList(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    BossID = 0    #(DWORD BossID)
    IsSort = 0    #(BYTE IsSort)// ÊÇ·ñÅÅÐò¹ýµÄ£¬Ò»°ãboss±»»÷ɱºó»áͳһͬ²½Ò»´ÎÅÅÐò¹ýµÄ×îÖÕ½á¹û£¬ÆäËûÇé¿öÏ¿ͻ§¶Ë×Ô¼ºÅÅÐò
    HurtCnt = 0    #(WORD HurtCnt)// ÉËѪÍæ¼Ò¸öÊý
    HurtPlayerList = list()    #(vector<tagMCHurtPlayer> HurtPlayerList)// ÉËѪÍæ¼ÒÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BossID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsSort,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HurtCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.HurtCnt):
            temHurtPlayerList = tagMCHurtPlayer()
            _pos = temHurtPlayerList.ReadData(_lpData, _pos)
            self.HurtPlayerList.append(temHurtPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x04
        self.ObjID = 0
        self.BossID = 0
        self.IsSort = 0
        self.HurtCnt = 0
        self.HurtPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        length += 2
        for i in range(self.HurtCnt):
            length += self.HurtPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteDWORD(data, self.BossID)
        data = CommFunc.WriteBYTE(data, self.IsSort)
        data = CommFunc.WriteWORD(data, self.HurtCnt)
        for i in range(self.HurtCnt):
            data = CommFunc.WriteString(data, self.HurtPlayerList[i].GetLength(), self.HurtPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                BossID:%d,
                                IsSort:%d,
                                HurtCnt:%d,
                                HurtPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.BossID,
                                self.IsSort,
                                self.HurtCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCBossHurtList=tagMCBossHurtList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBossHurtList.Head.Cmd,m_NAtagMCBossHurtList.Head.SubCmd))] = m_NAtagMCBossHurtList


#------------------------------------------------------
# A7 17 ÁÄÌìÆøÅÝ¿ò״̬ #tagMCChatBubbleBoxState

class  tagMCChatBubbleBox(Structure):
    _pack_ = 1
    _fields_ = [
                  ("BoxID", c_ubyte),    #ÆøÅÝID
                  ("State", c_ubyte),    #ÊÇ·ñÒѼ¤»î
                  ("EndTime", c_int),    #µ½ÆÚʱ¼ä´Á£¬0ΪÓÀ¾Ã
                  ("Star", c_ubyte),    #ÐǼ¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.BoxID = 0
        self.State = 0
        self.EndTime = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCChatBubbleBox)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 17 ÁÄÌìÆøÅÝ¿ò״̬ //tagMCChatBubbleBoxState:
                                BoxID:%d,
                                State:%d,
                                EndTime:%d,
                                Star:%d
                                '''\
                                %(
                                self.BoxID,
                                self.State,
                                self.EndTime,
                                self.Star
                                )
        return DumpString


class  tagMCChatBubbleBoxState(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    BoxList = list()    #(vector<tagMCChatBubbleBox> BoxList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBoxList = tagMCChatBubbleBox()
            _pos = temBoxList.ReadData(_lpData, _pos)
            self.BoxList.append(temBoxList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x17
        self.Count = 0
        self.BoxList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.BoxList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BoxList[i].GetLength(), self.BoxList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                BoxList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCChatBubbleBoxState=tagMCChatBubbleBoxState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChatBubbleBoxState.Head.Cmd,m_NAtagMCChatBubbleBoxState.Head.SubCmd))] = m_NAtagMCChatBubbleBoxState


#------------------------------------------------------
# A7 18 ²É¼¯½±ÀøÎïƷ֪ͨ #tagMCCollectAwardItemInfo

class  tagMCCollectAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("Count", c_ubyte),    
                  ("IsAuctionItem", c_ubyte),    #ÊÇ·ñÅÄÆ·
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.Count = 0
        self.IsAuctionItem = 0
        return

    def GetLength(self):
        return sizeof(tagMCCollectAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 18 ²É¼¯½±ÀøÎïƷ֪ͨ //tagMCCollectAwardItemInfo:
                                ItemID:%d,
                                Count:%d,
                                IsAuctionItem:%d
                                '''\
                                %(
                                self.ItemID,
                                self.Count,
                                self.IsAuctionItem
                                )
        return DumpString


class  tagMCCollectAwardItemInfo(Structure):
    Head = tagHead()
    CollectNPCID = 0    #(DWORD CollectNPCID)//²É¼¯µÄNPCID
    Count = 0    #(BYTE Count)
    AwardItemList = list()    #(vector<tagMCCollectAwardItem> AwardItemList)//½±ÀøÎïÆ·ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x18
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CollectNPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCollectAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x18
        self.CollectNPCID = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.CollectNPCID)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CollectNPCID:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CollectNPCID,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCCollectAwardItemInfo=tagMCCollectAwardItemInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCollectAwardItemInfo.Head.Cmd,m_NAtagMCCollectAwardItemInfo.Head.SubCmd))] = m_NAtagMCCollectAwardItemInfo


#------------------------------------------------------
# A7 20 ´´½Ç½±ÀøÁ콱״̬ #tagMCCreateRoleAwardState

class  tagMCCreateRoleAwardState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GetState", c_ubyte),    # ÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA7
        self.SubCmd = 0x20
        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 = 0xA7
        self.SubCmd = 0x20
        self.GetState = 0
        return

    def GetLength(self):
        return sizeof(tagMCCreateRoleAwardState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 20 ´´½Ç½±ÀøÁ콱״̬ //tagMCCreateRoleAwardState:
                                Cmd:%s,
                                SubCmd:%s,
                                GetState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GetState
                                )
        return DumpString


m_NAtagMCCreateRoleAwardState=tagMCCreateRoleAwardState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCreateRoleAwardState.Cmd,m_NAtagMCCreateRoleAwardState.SubCmd))] = m_NAtagMCCreateRoleAwardState


#------------------------------------------------------
# A7 13 ¶¯Ì¬ÕÏ°­Îï״̬ #tagMCDynamicBarrierState

class  tagMCDynamicBarrier(Structure):
    _pack_ = 1
    _fields_ = [
                  ("APosX", c_ushort),    
                  ("APosY", c_ushort),    
                  ("BPosX", c_ushort),    
                  ("BPosY", c_ushort),    
                  ("Angle", 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.APosX = 0
        self.APosY = 0
        self.BPosX = 0
        self.BPosY = 0
        self.Angle = 0
        return

    def GetLength(self):
        return sizeof(tagMCDynamicBarrier)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 13 ¶¯Ì¬ÕÏ°­Îï״̬ //tagMCDynamicBarrierState:
                                APosX:%d,
                                APosY:%d,
                                BPosX:%d,
                                BPosY:%d,
                                Angle:%d
                                '''\
                                %(
                                self.APosX,
                                self.APosY,
                                self.BPosX,
                                self.BPosY,
                                self.Angle
                                )
        return DumpString


class  tagMCDynamicBarrierState(Structure):
    Head = tagHead()
    State = 0    #(BYTE State)// ÊÇ·ñÓÐЧ
    Count = 0    #(BYTE Count)
    BarrierList = list()    #(vector<tagMCDynamicBarrier> BarrierList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.State,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBarrierList = tagMCDynamicBarrier()
            _pos = temBarrierList.ReadData(_lpData, _pos)
            self.BarrierList.append(temBarrierList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x13
        self.State = 0
        self.Count = 0
        self.BarrierList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.BarrierList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.State)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BarrierList[i].GetLength(), self.BarrierList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                State:%d,
                                Count:%d,
                                BarrierList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.State,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCDynamicBarrierState=tagMCDynamicBarrierState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDynamicBarrierState.Head.Cmd,m_NAtagMCDynamicBarrierState.Head.SubCmd))] = m_NAtagMCDynamicBarrierState


#------------------------------------------------------
# A7 21 ±íÇé°üÐÅÏ¢ #tagMCEmojiPackInfo

class  tagMCEmojiPack(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PackID", c_ubyte),    #±íÇé°üID
                  ("State", c_ubyte),    #ÊÇ·ñÒѼ¤»î
                  ("EndTime", 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.PackID = 0
        self.State = 0
        self.EndTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCEmojiPack)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 21 ±íÇé°üÐÅÏ¢ //tagMCEmojiPackInfo:
                                PackID:%d,
                                State:%d,
                                EndTime:%d
                                '''\
                                %(
                                self.PackID,
                                self.State,
                                self.EndTime
                                )
        return DumpString


class  tagMCEmojiPackInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    EmojiPackList = list()    #(vector<tagMCEmojiPack> EmojiPackList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x21
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temEmojiPackList = tagMCEmojiPack()
            _pos = temEmojiPackList.ReadData(_lpData, _pos)
            self.EmojiPackList.append(temEmojiPackList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x21
        self.Count = 0
        self.EmojiPackList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.EmojiPackList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.EmojiPackList[i].GetLength(), self.EmojiPackList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                EmojiPackList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCEmojiPackInfo=tagMCEmojiPackInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEmojiPackInfo.Head.Cmd,m_NAtagMCEmojiPackInfo.Head.SubCmd))] = m_NAtagMCEmojiPackInfo


#------------------------------------------------------
# A7 15 ֪ͨÏÉÃËÇÀBossÉËѪÐÅÏ¢ #tagMCFamilyBossHurtList

class  tagMCFamilyBossHurt(Structure):
    FamilyID = 0    #(DWORD FamilyID)// ËùÊôÏÉÃËID
    HurtID = 0    #(DWORD HurtID)// ÉËѪµÄID, ¸ù¾ÝÉËѪÀàÐͱíʾ²»Í¬µÄID, ÈçÏÉÃËID»òÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    HurtName = ""    #(String HurtName)
    HurtValue = 0    #(DWORD HurtValue)// ÀÛ¼ÆÉËѪ£¬ÇóÓà1ÒÚµÄÖµ
    HurtValueEx = 0    #(DWORD HurtValueEx)// ÀÛ¼ÆÉËѪ£¬Õû³ý1ÒÚµÄÖµ
    InitTick = 0    #(DWORD InitTick)// ÉËѪ³õʼtick£¬ÓÃÓÚÅÅÐò£¬ÏÈ°´ÉËѪµ¹ÐòÅÅ£¬ÔÙ°´tickÕýÐòÅÅ
    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.HurtID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HurtName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.HurtValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HurtValueEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.InitTick,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.FamilyID = 0
        self.HurtID = 0
        self.NameLen = 0
        self.HurtName = ""
        self.HurtValue = 0
        self.HurtValueEx = 0
        self.InitTick = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 1
        length += len(self.HurtName)
        length += 4
        length += 4
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.FamilyID)
        data = CommFunc.WriteDWORD(data, self.HurtID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.HurtName)
        data = CommFunc.WriteDWORD(data, self.HurtValue)
        data = CommFunc.WriteDWORD(data, self.HurtValueEx)
        data = CommFunc.WriteDWORD(data, self.InitTick)
        return data

    def OutputString(self):
        DumpString = '''
                                FamilyID:%d,
                                HurtID:%d,
                                NameLen:%d,
                                HurtName:%s,
                                HurtValue:%d,
                                HurtValueEx:%d,
                                InitTick:%d
                                '''\
                                %(
                                self.FamilyID,
                                self.HurtID,
                                self.NameLen,
                                self.HurtName,
                                self.HurtValue,
                                self.HurtValueEx,
                                self.InitTick
                                )
        return DumpString


class  tagMCFamilyBossHurtList(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    NPCID = 0    #(DWORD NPCID)
    HurtType = 0    #(BYTE HurtType)// 0-ʵʱÏÉÃËÉËѪ£¬1-ÀúÊ·ÏÉÃËÉËѪ£¬2-ʵʱÍæ¼ÒÉËѪ£¬3-ÀúÊ·Íæ¼ÒÉËѪ
    IsSort = 0    #(BYTE IsSort)// ÊÇ·ñÅÅÐò¹ýµÄ£¬Ò»°ãboss±»»÷ɱºó»áͳһͬ²½Ò»´ÎÅÅÐò¹ýµÄ×îÖÕ½á¹û£¬ÆäËûÇé¿öÏ¿ͻ§¶Ë×Ô¼ºÅÅÐò
    HurtCount = 0    #(WORD HurtCount)// ÉËѪ¸öÊý
    HurtList = list()    #(vector<tagMCFamilyBossHurt> HurtList)// ÉËѪÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HurtType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsSort,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HurtCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.HurtCount):
            temHurtList = tagMCFamilyBossHurt()
            _pos = temHurtList.ReadData(_lpData, _pos)
            self.HurtList.append(temHurtList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x15
        self.ObjID = 0
        self.NPCID = 0
        self.HurtType = 0
        self.IsSort = 0
        self.HurtCount = 0
        self.HurtList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        length += 1
        length += 2
        for i in range(self.HurtCount):
            length += self.HurtList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteBYTE(data, self.HurtType)
        data = CommFunc.WriteBYTE(data, self.IsSort)
        data = CommFunc.WriteWORD(data, self.HurtCount)
        for i in range(self.HurtCount):
            data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                NPCID:%d,
                                HurtType:%d,
                                IsSort:%d,
                                HurtCount:%d,
                                HurtList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.NPCID,
                                self.HurtType,
                                self.IsSort,
                                self.HurtCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFamilyBossHurtList=tagMCFamilyBossHurtList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyBossHurtList.Head.Cmd,m_NAtagMCFamilyBossHurtList.Head.SubCmd))] = m_NAtagMCFamilyBossHurtList


#------------------------------------------------------
# A7 03 ֪ͨ½øÈ븱±¾Ê±¼ä #tagMCFBEnterTickList

class  tagMCFBEnterTick(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MapID", c_int),    # ¸±±¾µØͼid
                  ("LastEnterTick", c_int),    # ÉϴνøÈ븱±¾Ê±¼ä
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.MapID = 0
        self.LastEnterTick = 0
        return

    def GetLength(self):
        return sizeof(tagMCFBEnterTick)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 03 ֪ͨ½øÈ븱±¾Ê±¼ä //tagMCFBEnterTickList:
                                MapID:%d,
                                LastEnterTick:%d
                                '''\
                                %(
                                self.MapID,
                                self.LastEnterTick
                                )
        return DumpString


class  tagMCFBEnterTickList(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// ÐÅÏ¢¸öÊý
    EnterTickList = list()    #(vector<tagMCFBEnterTick> EnterTickList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temEnterTickList = tagMCFBEnterTick()
            _pos = temEnterTickList.ReadData(_lpData, _pos)
            self.EnterTickList.append(temEnterTickList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x03
        self.Cnt = 0
        self.EnterTickList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.EnterTickList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.EnterTickList[i].GetLength(), self.EnterTickList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                EnterTickList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFBEnterTickList=tagMCFBEnterTickList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBEnterTickList.Head.Cmd,m_NAtagMCFBEnterTickList.Head.SubCmd))] = m_NAtagMCFBEnterTickList


#------------------------------------------------------
# A7 10 Òýµ¼×´Ì¬¼Ç¼ #tagMCGuideState

class  tagMCGuideState(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    GuideState = list()    #(vector<DWORD> GuideState)// ÿ¸öÊýÖµ´æ´¢31λ(0~30)£¬Ä¿Ç°×î¶à´æ´¢Count*31λ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x10
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.GuideState.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x10
        self.Count = 0
        self.GuideState = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.GuideState[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                GuideState:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCGuideState=tagMCGuideState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGuideState.Head.Cmd,m_NAtagMCGuideState.Head.SubCmd))] = m_NAtagMCGuideState


#------------------------------------------------------
# A7 16 СÖúÊÖÉèÖà #tagMCLittleHelperSet

class  tagMCLittleHelperFuncSet(Structure):
    _pack_ = 1
    _fields_ = [
                  ("SetNum", c_ubyte),    # Íйܹ¦ÄÜÉèÖñàºÅ1~20£¬Ã¿¸ö±àºÅ¶ÔÓ¦µÄÍйܹ¦ÄÜÇ°¶Ë×Ô¶¨Òå
                  ("Value1", c_int),    # ×Ô¶¨ÒåÖµ1£¬Èç¹û´æ´¢µÄÊǹ´Ñ¡ÐÅÏ¢, °´¶þ½øÖÆλ´æ´¢´ú±íÊÇ·ñ¹´Ñ¡£¬Ö§³Ö31λ£¬Ã¿Î»´ú±íµÄº¬ÒåÇ°¶Ë×Ô¶¨Òå
                  ("Value2", c_int),    # ×Ô¶¨ÒåÖµ2
                  ("Value3", c_int),    # ×Ô¶¨ÒåÖµ3
                  ("Value4", c_int),    # ×Ô¶¨ÒåÖµ4
                  ("Value5", c_int),    # ×Ô¶¨ÒåÖµ5
                  ("Value6", c_int),    # ×Ô¶¨ÒåÖµ6
                  ]

    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.SetNum = 0
        self.Value1 = 0
        self.Value2 = 0
        self.Value3 = 0
        self.Value4 = 0
        self.Value5 = 0
        self.Value6 = 0
        return

    def GetLength(self):
        return sizeof(tagMCLittleHelperFuncSet)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 16 СÖúÊÖÉèÖà //tagMCLittleHelperSet:
                                SetNum:%d,
                                Value1:%d,
                                Value2:%d,
                                Value3:%d,
                                Value4:%d,
                                Value5:%d,
                                Value6:%d
                                '''\
                                %(
                                self.SetNum,
                                self.Value1,
                                self.Value2,
                                self.Value3,
                                self.Value4,
                                self.Value5,
                                self.Value6
                                )
        return DumpString


class  tagMCLittleHelperSet(Structure):
    Head = tagHead()
    FuncSetCount = 0    #(BYTE FuncSetCount)// Íйܹ¦ÄÜÉèÖÃÊý£¬ÔÝÖ§³Ö20¸ö
    FuncSetList = list()    #(vector<tagMCLittleHelperFuncSet> FuncSetList)// Íйܹ¦ÄÜÉèÖÃÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x16
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FuncSetCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FuncSetCount):
            temFuncSetList = tagMCLittleHelperFuncSet()
            _pos = temFuncSetList.ReadData(_lpData, _pos)
            self.FuncSetList.append(temFuncSetList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x16
        self.FuncSetCount = 0
        self.FuncSetList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.FuncSetCount):
            length += self.FuncSetList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FuncSetCount)
        for i in range(self.FuncSetCount):
            data = CommFunc.WriteString(data, self.FuncSetList[i].GetLength(), self.FuncSetList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FuncSetCount:%d,
                                FuncSetList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FuncSetCount,
                                "..."
                                )
        return DumpString


m_NAtagMCLittleHelperSet=tagMCLittleHelperSet()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLittleHelperSet.Head.Cmd,m_NAtagMCLittleHelperSet.Head.SubCmd))] = m_NAtagMCLittleHelperSet


#------------------------------------------------------
# A7 14 ֪ͨ²éѯµÄNPCÊýÁ¿ #tagMCNPCCntList

class  tagMCNPCCntInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NPCID", c_int),    
                  ("Cnt", 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.NPCID = 0
        self.Cnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCCntInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 14 ֪ͨ²éѯµÄNPCÊýÁ¿ //tagMCNPCCntList:
                                NPCID:%d,
                                Cnt:%d
                                '''\
                                %(
                                self.NPCID,
                                self.Cnt
                                )
        return DumpString


class  tagMCNPCCntList(Structure):
    Head = tagHead()
    MapID = 0    #(DWORD MapID)
    NPCInfoCnt = 0    #(BYTE NPCInfoCnt)
    NPCInfoList = list()    #(vector<tagMCNPCCntInfo> NPCInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x14
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCInfoCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.NPCInfoCnt):
            temNPCInfoList = tagMCNPCCntInfo()
            _pos = temNPCInfoList.ReadData(_lpData, _pos)
            self.NPCInfoList.append(temNPCInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x14
        self.MapID = 0
        self.NPCInfoCnt = 0
        self.NPCInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.NPCInfoCnt):
            length += self.NPCInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteBYTE(data, self.NPCInfoCnt)
        for i in range(self.NPCInfoCnt):
            data = CommFunc.WriteString(data, self.NPCInfoList[i].GetLength(), self.NPCInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                MapID:%d,
                                NPCInfoCnt:%d,
                                NPCInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.MapID,
                                self.NPCInfoCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCNPCCntList=tagMCNPCCntList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCCntList.Head.Cmd,m_NAtagMCNPCCntList.Head.SubCmd))] = m_NAtagMCNPCCntList


#------------------------------------------------------
#A7 01 ֪ͨѡÖжÔÏó # tagMCNotifySelectObj

class  tagMCNotifySelectObj(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("isSelect", c_ubyte),    #0 ²»Ñ¡ÖÐ
                  ("Type", c_ubyte),    #Ä¿±êÀàÐÍ
                  ("ID", c_int),    #ID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA7
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA7
        self.SubCmd = 0x01
        self.isSelect = 0
        self.Type = 0
        self.ID = 0
        return

    def GetLength(self):
        return sizeof(tagMCNotifySelectObj)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A7 01 ֪ͨѡÖжÔÏó // tagMCNotifySelectObj:
                                Cmd:%s,
                                SubCmd:%s,
                                isSelect:%d,
                                Type:%d,
                                ID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.isSelect,
                                self.Type,
                                self.ID
                                )
        return DumpString


m_NAtagMCNotifySelectObj=tagMCNotifySelectObj()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifySelectObj.Cmd,m_NAtagMCNotifySelectObj.SubCmd))] = m_NAtagMCNotifySelectObj


#------------------------------------------------------
# A7 06 ֪ͨ²éѯµÄNPCÐÅÏ¢ #tagMCNPCInfoList

class  tagMCNPCInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ObjID", c_int),    
                  ("NPCID", c_int),    
                  ("NPCHP", c_int),    
                  ("MaxHP", c_int),    
                  ("IsActive", c_ubyte),    #Õâ¸öNPCÊÇ·ñ»î×Å
                  ("PosX", c_ushort),    
                  ("PosY", c_ushort),    
                  ("RefreshSecond", 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.ObjID = 0
        self.NPCID = 0
        self.NPCHP = 0
        self.MaxHP = 0
        self.IsActive = 0
        self.PosX = 0
        self.PosY = 0
        self.RefreshSecond = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 06 ֪ͨ²éѯµÄNPCÐÅÏ¢ //tagMCNPCInfoList:
                                ObjID:%d,
                                NPCID:%d,
                                NPCHP:%d,
                                MaxHP:%d,
                                IsActive:%d,
                                PosX:%d,
                                PosY:%d,
                                RefreshSecond:%d
                                '''\
                                %(
                                self.ObjID,
                                self.NPCID,
                                self.NPCHP,
                                self.MaxHP,
                                self.IsActive,
                                self.PosX,
                                self.PosY,
                                self.RefreshSecond
                                )
        return DumpString


class  tagMCNPCInfoList(Structure):
    Head = tagHead()
    MapID = 0    #(DWORD MapID)
    PlayerCnt = 0    #(WORD PlayerCnt)
    NPCInfoCnt = 0    #(BYTE NPCInfoCnt)
    NPCInfoList = list()    #(vector<tagMCNPCInfo> NPCInfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.NPCInfoCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.NPCInfoCnt):
            temNPCInfoList = tagMCNPCInfo()
            _pos = temNPCInfoList.ReadData(_lpData, _pos)
            self.NPCInfoList.append(temNPCInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x06
        self.MapID = 0
        self.PlayerCnt = 0
        self.NPCInfoCnt = 0
        self.NPCInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 1
        for i in range(self.NPCInfoCnt):
            length += self.NPCInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteWORD(data, self.PlayerCnt)
        data = CommFunc.WriteBYTE(data, self.NPCInfoCnt)
        for i in range(self.NPCInfoCnt):
            data = CommFunc.WriteString(data, self.NPCInfoList[i].GetLength(), self.NPCInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                MapID:%d,
                                PlayerCnt:%d,
                                NPCInfoCnt:%d,
                                NPCInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.MapID,
                                self.PlayerCnt,
                                self.NPCInfoCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCNPCInfoList=tagMCNPCInfoList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCInfoList.Head.Cmd,m_NAtagMCNPCInfoList.Head.SubCmd))] = m_NAtagMCNPCInfoList


#------------------------------------------------------
#A7 02 ֪ͨµØͼ³öÏÖÕÙ»½NPC #tagMCSummonMapNPC

class  tagMCSummonMapNPC(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("NPCID", c_int),    
                  ("PosX", c_ushort),    
                  ("PosY", c_ushort),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA7
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xA7
        self.SubCmd = 0x02
        self.NPCID = 0
        self.PosX = 0
        self.PosY = 0
        return

    def GetLength(self):
        return sizeof(tagMCSummonMapNPC)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A7 02 ֪ͨµØͼ³öÏÖÕÙ»½NPC //tagMCSummonMapNPC:
                                Cmd:%s,
                                SubCmd:%s,
                                NPCID:%d,
                                PosX:%d,
                                PosY:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.NPCID,
                                self.PosX,
                                self.PosY
                                )
        return DumpString


m_NAtagMCSummonMapNPC=tagMCSummonMapNPC()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSummonMapNPC.Cmd,m_NAtagMCSummonMapNPC.SubCmd))] = m_NAtagMCSummonMapNPC


#------------------------------------------------------
# A7 12 ÏÔʾNPCÐã #tagMCNPCShow

class  tagMCNPCShow(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("NPCID", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA7
        self.SubCmd = 0x12
        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 = 0xA7
        self.SubCmd = 0x12
        self.NPCID = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCShow)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 12 ÏÔʾNPCÐã //tagMCNPCShow:
                                Cmd:%s,
                                SubCmd:%s,
                                NPCID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.NPCID
                                )
        return DumpString


m_NAtagMCNPCShow=tagMCNPCShow()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCShow.Cmd,m_NAtagMCNPCShow.SubCmd))] = m_NAtagMCNPCShow


#------------------------------------------------------
# A7 19 ²éѯÍæ¼Ò¾³½ç½××°±¸ÐÅÏ¢½á¹û #tagSCPlayerEquipCacheResult

class  tagSCPlayerEquipCacheResult(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    EquipClassLV = 0    #(BYTE EquipClassLV)
    ItemDataSize = 0    #(WORD ItemDataSize)
    ItemData = ""    #(String ItemData)//ÎïÆ·¼Ç¼	
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x19
        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.EquipClassLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemDataSize,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataSize)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x19
        self.PlayerID = 0
        self.EquipClassLV = 0
        self.ItemDataSize = 0
        self.ItemData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 2
        length += len(self.ItemData)

        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.EquipClassLV)
        data = CommFunc.WriteWORD(data, self.ItemDataSize)
        data = CommFunc.WriteString(data, self.ItemDataSize, self.ItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                EquipClassLV:%d,
                                ItemDataSize:%d,
                                ItemData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.EquipClassLV,
                                self.ItemDataSize,
                                self.ItemData
                                )
        return DumpString


m_NAtagSCPlayerEquipCacheResult=tagSCPlayerEquipCacheResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCPlayerEquipCacheResult.Head.Cmd,m_NAtagSCPlayerEquipCacheResult.Head.SubCmd))] = m_NAtagSCPlayerEquipCacheResult


#------------------------------------------------------
# A7 07 ֪ͨÍæ¼Ò×Ô¶¨ÒåÁÄÌì #tagMCPyTalk

class  tagMCPyTalk(Structure):
    Head = tagHead()
    TalkType = 0    #(BYTE TalkType)// ×Ô¶¨ÒåÁÄÌìÀàÐÍ
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//size = NameLen
    PlayerID = 0    #(DWORD PlayerID)
    Len = 0    #(WORD Len)
    Content = ""    #(String Content)//size = Len
    ExtraValue = 0    #(DWORD ExtraValue)//¸½¼ÓÖµ
    Extras = ""    #(char Extras[256])//¸½¼ÓÖµÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x07
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TalkType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Content,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        self.ExtraValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,256)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x07
        self.TalkType = 0
        self.NameLen = 0
        self.Name = ""
        self.PlayerID = 0
        self.Len = 0
        self.Content = ""
        self.ExtraValue = 0
        self.Extras = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += len(self.Name)
        length += 4
        length += 2
        length += len(self.Content)
        length += 4
        length += 256

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TalkType)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.Content)
        data = CommFunc.WriteDWORD(data, self.ExtraValue)
        data = CommFunc.WriteString(data, 256, self.Extras)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TalkType:%d,
                                NameLen:%d,
                                Name:%s,
                                PlayerID:%d,
                                Len:%d,
                                Content:%s,
                                ExtraValue:%d,
                                Extras:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TalkType,
                                self.NameLen,
                                self.Name,
                                self.PlayerID,
                                self.Len,
                                self.Content,
                                self.ExtraValue,
                                self.Extras
                                )
        return DumpString


m_NAtagMCPyTalk=tagMCPyTalk()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPyTalk.Head.Cmd,m_NAtagMCPyTalk.Head.SubCmd))] = m_NAtagMCPyTalk


#------------------------------------------------------
# A7 08 ֪ͨÅÜ»·½±Àø¼Ç¼ #tagMCRunTaskAwardInfo

class  tagMCRunTaskAwardRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    
                  ("Num", c_int),    
                  ("AwardState", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Type = 0
        self.Num = 0
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCRunTaskAwardRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 08 ֪ͨÅÜ»·½±Àø¼Ç¼ //tagMCRunTaskAwardInfo:
                                Type:%d,
                                Num:%d,
                                AwardState:%d
                                '''\
                                %(
                                self.Type,
                                self.Num,
                                self.AwardState
                                )
        return DumpString


class  tagMCRunTaskAwardInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)
    InfoList = list()    #(vector<tagMCRunTaskAwardRecord> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x08
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCRunTaskAwardRecord()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x08
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCRunTaskAwardInfo=tagMCRunTaskAwardInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRunTaskAwardInfo.Head.Cmd,m_NAtagMCRunTaskAwardInfo.Head.SubCmd))] = m_NAtagMCRunTaskAwardInfo


#------------------------------------------------------
#A7 05 ²éѯÍæ¼ÒÏêϸÐÅÏ¢½á¹û#tagSCQueryPlayerCacheResult

class  tagSCQueryPlayerCacheResult(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PropDataSize = 0    #(DWORD PropDataSize)
    PropData = ""    #(String PropData)//ÊôÐԼǼ
    ItemDataSize = 0    #(DWORD ItemDataSize)
    ItemData = ""    #(String ItemData)//ÎïÆ·¼Ç¼
    PlusDataSize = 0    #(DWORD PlusDataSize)
    PlusData = ""    #(String PlusData)//À©Õ¹¼Ç¼	
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x05
        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.PropDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PropData,_pos = CommFunc.ReadString(_lpData, _pos,self.PropDataSize)
        self.ItemDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataSize)
        self.PlusDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlusData,_pos = CommFunc.ReadString(_lpData, _pos,self.PlusDataSize)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x05
        self.PlayerID = 0
        self.PropDataSize = 0
        self.PropData = ""
        self.ItemDataSize = 0
        self.ItemData = ""
        self.PlusDataSize = 0
        self.PlusData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += len(self.PropData)
        length += 4
        length += len(self.ItemData)
        length += 4
        length += len(self.PlusData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteDWORD(data, self.PropDataSize)
        data = CommFunc.WriteString(data, self.PropDataSize, self.PropData)
        data = CommFunc.WriteDWORD(data, self.ItemDataSize)
        data = CommFunc.WriteString(data, self.ItemDataSize, self.ItemData)
        data = CommFunc.WriteDWORD(data, self.PlusDataSize)
        data = CommFunc.WriteString(data, self.PlusDataSize, self.PlusData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PropDataSize:%d,
                                PropData:%s,
                                ItemDataSize:%d,
                                ItemData:%s,
                                PlusDataSize:%d,
                                PlusData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PropDataSize,
                                self.PropData,
                                self.ItemDataSize,
                                self.ItemData,
                                self.PlusDataSize,
                                self.PlusData
                                )
        return DumpString


m_NAtagSCQueryPlayerCacheResult=tagSCQueryPlayerCacheResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCQueryPlayerCacheResult.Head.Cmd,m_NAtagSCQueryPlayerCacheResult.Head.SubCmd))] = m_NAtagSCQueryPlayerCacheResult


#------------------------------------------------------
# A7 11 ÏÔʾÒýµ¼ #tagMCShowGuide

class  tagMCShowGuide(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("GuideID", c_ushort),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA7
        self.SubCmd = 0x11
        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 = 0xA7
        self.SubCmd = 0x11
        self.GuideID = 0
        return

    def GetLength(self):
        return sizeof(tagMCShowGuide)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A7 11 ÏÔʾÒýµ¼ //tagMCShowGuide:
                                Cmd:%s,
                                SubCmd:%s,
                                GuideID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.GuideID
                                )
        return DumpString


m_NAtagMCShowGuide=tagMCShowGuide()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShowGuide.Cmd,m_NAtagMCShowGuide.SubCmd))] = m_NAtagMCShowGuide


#------------------------------------------------------
#A7 09 ÖÜΧ¶ÔÏóˢкϲ¢°ü #tagObjInfoListRefresh

class  tagRefreshType(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RefreshType", c_ushort),    
                  ("Value", c_int),    
                  ("ValueEx", 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.RefreshType = 0
        self.Value = 0
        self.ValueEx = 0
        return

    def GetLength(self):
        return sizeof(tagRefreshType)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//A7 09 ÖÜΧ¶ÔÏóˢкϲ¢°ü //tagObjInfoListRefresh:
                                RefreshType:%d,
                                Value:%d,
                                ValueEx:%d
                                '''\
                                %(
                                self.RefreshType,
                                self.Value,
                                self.ValueEx
                                )
        return DumpString


class  tagObjInfoListRefresh(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    ObjType = 0    #(BYTE ObjType)
    Count = 0    #(BYTE Count)
    RefreshType = list()    #(vector<tagRefreshType> RefreshType)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ObjType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temRefreshType = tagRefreshType()
            _pos = temRefreshType.ReadData(_lpData, _pos)
            self.RefreshType.append(temRefreshType)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA7
        self.Head.SubCmd = 0x09
        self.ObjID = 0
        self.ObjType = 0
        self.Count = 0
        self.RefreshType = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.RefreshType[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteBYTE(data, self.ObjType)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.RefreshType[i].GetLength(), self.RefreshType[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                ObjType:%d,
                                Count:%d,
                                RefreshType:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.ObjType,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagObjInfoListRefresh=tagObjInfoListRefresh()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagObjInfoListRefresh.Head.Cmd,m_NAtagObjInfoListRefresh.Head.SubCmd))] = m_NAtagObjInfoListRefresh


#------------------------------------------------------
# A8 12 ÊØ»¤³É¹¦Ê°È¡ÎïÆ· #tagMCGuradPickupItemSucc

class  tagMCGuradPickupItemSucc(Structure):
    Head = tagHead()
    ItemCount = 0    #(WORD ItemCount)
    MapItemID = list()    #(vector<WORD> MapItemID)//size = ItemCount
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x12
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.ItemCount):
            value,_pos=CommFunc.ReadWORD(_lpData,_pos)
            self.MapItemID.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x12
        self.ItemCount = 0
        self.MapItemID = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 2 * self.ItemCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.ItemCount)
        for i in range(self.ItemCount):
            data = CommFunc.WriteWORD(data, self.MapItemID[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemCount:%d,
                                MapItemID:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemCount,
                                "..."
                                )
        return DumpString


m_NAtagMCGuradPickupItemSucc=tagMCGuradPickupItemSucc()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGuradPickupItemSucc.Head.Cmd,m_NAtagMCGuradPickupItemSucc.Head.SubCmd))] = m_NAtagMCGuradPickupItemSucc


#------------------------------------------------------
# A8 09 ֪ͨÎïÆ·µ±ÈÕÒÑʹÓôÎÊý #tagMCItemDayUseCntInfo

class  tagMCItemDayUseCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("UseCnt", 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.UseCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCItemDayUseCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 09 ֪ͨÎïÆ·µ±ÈÕÒÑʹÓôÎÊý //tagMCItemDayUseCntInfo:
                                ItemID:%d,
                                UseCnt:%d
                                '''\
                                %(
                                self.ItemID,
                                self.UseCnt
                                )
        return DumpString


class  tagMCItemDayUseCntInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)//ÐÅÏ¢Êý
    ItemUseCntList = list()    #(vector<tagMCItemDayUseCnt> ItemUseCntList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temItemUseCntList = tagMCItemDayUseCnt()
            _pos = temItemUseCntList.ReadData(_lpData, _pos)
            self.ItemUseCntList.append(temItemUseCntList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x09
        self.Count = 0
        self.ItemUseCntList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.ItemUseCntList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ItemUseCntList[i].GetLength(), self.ItemUseCntList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ItemUseCntList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCItemDayUseCntInfo=tagMCItemDayUseCntInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCItemDayUseCntInfo.Head.Cmd,m_NAtagMCItemDayUseCntInfo.Head.SubCmd))] = m_NAtagMCItemDayUseCntInfo


#------------------------------------------------------
# A8 15 ÁéÆ÷Í»Æƽá¹û #tagMCLingQiEquipBreakResult

class  tagMCLingQiEquipBreakResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MakeItemID", c_int),    #Í»ÆƺóµÄÎïÆ·ID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA8
        self.SubCmd = 0x15
        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 = 0xA8
        self.SubCmd = 0x15
        self.MakeItemID = 0
        return

    def GetLength(self):
        return sizeof(tagMCLingQiEquipBreakResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 15 ÁéÆ÷Í»Æƽá¹û //tagMCLingQiEquipBreakResult:
                                Cmd:%s,
                                SubCmd:%s,
                                MakeItemID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MakeItemID
                                )
        return DumpString


m_NAtagMCLingQiEquipBreakResult=tagMCLingQiEquipBreakResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLingQiEquipBreakResult.Cmd,m_NAtagMCLingQiEquipBreakResult.SubCmd))] = m_NAtagMCLingQiEquipBreakResult


#------------------------------------------------------
# A8 18 ÁéÆ÷ÅàÑøÐÅÏ¢ #tagMCLingQiTrainInfo

class  tagMCLingQiTrainInfo(Structure):
    Head = tagHead()
    EquipPlace = 0    #(BYTE EquipPlace)//ÁéÆ÷×°±¸Î»
    TrainTypes = 0    #(BYTE TrainTypes)//ÅàÑøÀàÐÍÊý
    TrainLVList = list()    #(vector<DWORD> TrainLVList)//ÅàÑøµÈ½×ÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    TrainItemCountList = list()    #(vector<DWORD> TrainItemCountList)//ÅàÑøµ±Ç°½×ÒѳÔÅàÑøµ¤¸öÊýÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x18
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.EquipPlace,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TrainTypes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainLVList.append(value)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainItemCountList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x18
        self.EquipPlace = 0
        self.TrainTypes = 0
        self.TrainLVList = list()
        self.TrainItemCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4 * self.TrainTypes
        length += 4 * self.TrainTypes

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.EquipPlace)
        data = CommFunc.WriteBYTE(data, self.TrainTypes)
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainLVList[i])
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainItemCountList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                EquipPlace:%d,
                                TrainTypes:%d,
                                TrainLVList:%s,
                                TrainItemCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.EquipPlace,
                                self.TrainTypes,
                                "...",
                                "..."
                                )
        return DumpString


m_NAtagMCLingQiTrainInfo=tagMCLingQiTrainInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLingQiTrainInfo.Head.Cmd,m_NAtagMCLingQiTrainInfo.Head.SubCmd))] = m_NAtagMCLingQiTrainInfo


#------------------------------------------------------
# A8 14 ºÏ³É½á¹û֪ͨ #tagMCMakeItemAnswer

class  tagMCMakeItemAnswer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MakeType", c_ubyte),    #ÀàÐÍ		TMakeItemType
                  ("Result", c_ubyte),    #ÊÇ·ñ³É¹¦
                  ("MakeItemID", c_int),    #ºÏ³ÉµÄÎïÆ·ID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA8
        self.SubCmd = 0x14
        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 = 0xA8
        self.SubCmd = 0x14
        self.MakeType = 0
        self.Result = 0
        self.MakeItemID = 0
        return

    def GetLength(self):
        return sizeof(tagMCMakeItemAnswer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 14 ºÏ³É½á¹û֪ͨ //tagMCMakeItemAnswer:
                                Cmd:%s,
                                SubCmd:%s,
                                MakeType:%d,
                                Result:%d,
                                MakeItemID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MakeType,
                                self.Result,
                                self.MakeItemID
                                )
        return DumpString


m_NAtagMCMakeItemAnswer=tagMCMakeItemAnswer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMakeItemAnswer.Cmd,m_NAtagMCMakeItemAnswer.SubCmd))] = m_NAtagMCMakeItemAnswer


#------------------------------------------------------
# A8 11 É̵깺Âò½á¹û #tagMCShoppingResult

class  tagMCShoppingResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ItemIndex", c_int),    
                  ("ItemCnt", c_int),    #¹ºÂòÊýÁ¿
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xA8
        self.SubCmd = 0x11
        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 = 0xA8
        self.SubCmd = 0x11
        self.ItemIndex = 0
        self.ItemCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCShoppingResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 11 É̵깺Âò½á¹û //tagMCShoppingResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ItemIndex:%d,
                                ItemCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ItemIndex,
                                self.ItemCnt
                                )
        return DumpString


m_NAtagMCShoppingResult=tagMCShoppingResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShoppingResult.Cmd,m_NAtagMCShoppingResult.SubCmd))] = m_NAtagMCShoppingResult


#------------------------------------------------------
# A8 16 ÉñÃØÉ̵êÉÌÆ·ÐÅÏ¢ #tagMCMysticalShopInfo

class  tagMCMysticalShopGoods(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GoodsID", c_int),    # ÉÌÆ·ID
                  ]

    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.GoodsID = 0
        return

    def GetLength(self):
        return sizeof(tagMCMysticalShopGoods)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 16 ÉñÃØÉ̵êÉÌÆ·ÐÅÏ¢ //tagMCMysticalShopInfo:
                                GoodsID:%d
                                '''\
                                %(
                                self.GoodsID
                                )
        return DumpString


class  tagMCMysticalShopInfo(Structure):
    Head = tagHead()
    RefreshCnt = 0    #(WORD RefreshCnt)// ˢдÎÊý
    Count = 0    #(BYTE Count)// ÉÌÆ·Êý
    GoodsList = list()    #(vector<tagMCMysticalShopGoods> GoodsList)// ÉÌÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x16
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RefreshCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temGoodsList = tagMCMysticalShopGoods()
            _pos = temGoodsList.ReadData(_lpData, _pos)
            self.GoodsList.append(temGoodsList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x16
        self.RefreshCnt = 0
        self.Count = 0
        self.GoodsList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 1
        for i in range(self.Count):
            length += self.GoodsList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RefreshCnt)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.GoodsList[i].GetLength(), self.GoodsList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RefreshCnt:%d,
                                Count:%d,
                                GoodsList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RefreshCnt,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCMysticalShopInfo=tagMCMysticalShopInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMysticalShopInfo.Head.Cmd,m_NAtagMCMysticalShopInfo.Head.SubCmd))] = m_NAtagMCMysticalShopInfo


#------------------------------------------------------
# A8 06 ֪ͨÉñÃØÏÞ¹ºÉÌƷʱ¼ä #tagMCMysticalShopTimeInfo

class  tagMCMysticalShopTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GoodsID", c_int),    # ÉÌÆ·ID
                  ("StartTime", 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.GoodsID = 0
        self.StartTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCMysticalShopTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 06 ֪ͨÉñÃØÏÞ¹ºÉÌƷʱ¼ä //tagMCMysticalShopTimeInfo:
                                GoodsID:%d,
                                StartTime:%d
                                '''\
                                %(
                                self.GoodsID,
                                self.StartTime
                                )
        return DumpString


class  tagMCMysticalShopTimeInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)// ÉÌÆ·Êý
    ShopTimeList = list()    #(vector<tagMCMysticalShopTime> ShopTimeList)// ÉÌÆ·¿ªÂôÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temShopTimeList = tagMCMysticalShopTime()
            _pos = temShopTimeList.ReadData(_lpData, _pos)
            self.ShopTimeList.append(temShopTimeList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x06
        self.Count = 0
        self.ShopTimeList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.ShopTimeList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ShopTimeList[i].GetLength(), self.ShopTimeList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                ShopTimeList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCMysticalShopTimeInfo=tagMCMysticalShopTimeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMysticalShopTimeInfo.Head.Cmd,m_NAtagMCMysticalShopTimeInfo.Head.SubCmd))] = m_NAtagMCMysticalShopTimeInfo


#------------------------------------------------------
# A8 10 ֪ͨ»ñµÃÎïÆ· #tagMCNotifyUseItemGetItem

class  tagMCNotifyUseItemGetItem(Structure):
    Head = tagHead()
    UseItemID = 0    #(DWORD UseItemID)// ʹÓõÄÎïÆ·ID
    UseCount = 0    #(WORD UseCount)// ʹÓÃÎïÆ·¸öÊý
    GetItemLen = 0    #(WORD GetItemLen)
    GetItemData = ""    #(String GetItemData)//  »ñµÃÎïÆ·ÐÅÏ¢ [[itemID,itemCount,isBind], [»òitemID,itemCount,isBind,isAppoint], {»òÎïÆ·ÐÅÏ¢×Öµä}, ...] 
    MoneyType = 0    #(BYTE MoneyType)// »ñµÃ»õ±ÒÀàÐÍ
    MoneyCount = 0    #(DWORD MoneyCount)// »ñµÃ»õ±ÒÊýÁ¿
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x10
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.UseItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UseCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GetItemLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GetItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.GetItemLen)
        self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x10
        self.UseItemID = 0
        self.UseCount = 0
        self.GetItemLen = 0
        self.GetItemData = ""
        self.MoneyType = 0
        self.MoneyCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 2
        length += len(self.GetItemData)
        length += 1
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.UseItemID)
        data = CommFunc.WriteWORD(data, self.UseCount)
        data = CommFunc.WriteWORD(data, self.GetItemLen)
        data = CommFunc.WriteString(data, self.GetItemLen, self.GetItemData)
        data = CommFunc.WriteBYTE(data, self.MoneyType)
        data = CommFunc.WriteDWORD(data, self.MoneyCount)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                UseItemID:%d,
                                UseCount:%d,
                                GetItemLen:%d,
                                GetItemData:%s,
                                MoneyType:%d,
                                MoneyCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.UseItemID,
                                self.UseCount,
                                self.GetItemLen,
                                self.GetItemData,
                                self.MoneyType,
                                self.MoneyCount
                                )
        return DumpString


m_NAtagMCNotifyUseItemGetItem=tagMCNotifyUseItemGetItem()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifyUseItemGetItem.Head.Cmd,m_NAtagMCNotifyUseItemGetItem.Head.SubCmd))] = m_NAtagMCNotifyUseItemGetItem


#------------------------------------------------------
# A8 17 ³èÎïÅàÑøÐÅÏ¢ #tagMCPetTrainInfo

class  tagMCPetTrainInfo(Structure):
    Head = tagHead()
    TrainTypes = 0    #(BYTE TrainTypes)//ÅàÑøÀàÐÍÊý
    TrainLVList = list()    #(vector<DWORD> TrainLVList)//ÅàÑøµÈ½×ÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    TrainItemCountList = list()    #(vector<DWORD> TrainItemCountList)//ÅàÑøµ±Ç°½×ÒѳÔÅàÑøµ¤¸öÊýÁÐ±í£¬Ë÷ÒýΪÅàÑøÀàÐͼõ1
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TrainTypes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainLVList.append(value)
        for i in range(self.TrainTypes):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.TrainItemCountList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x17
        self.TrainTypes = 0
        self.TrainLVList = list()
        self.TrainItemCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4 * self.TrainTypes
        length += 4 * self.TrainTypes

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TrainTypes)
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainLVList[i])
        for i in range(self.TrainTypes):
            data = CommFunc.WriteDWORD(data, self.TrainItemCountList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TrainTypes:%d,
                                TrainLVList:%s,
                                TrainItemCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TrainTypes,
                                "...",
                                "..."
                                )
        return DumpString


m_NAtagMCPetTrainInfo=tagMCPetTrainInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPetTrainInfo.Head.Cmd,m_NAtagMCPetTrainInfo.Head.SubCmd))] = m_NAtagMCPetTrainInfo


#------------------------------------------------------
# A8 02 ֪ͨNPCÉ̵êÎïÆ·½ñÈÕÒѹºÂò´ÎÊý #tagMCShopItemDayBuyCntInfo

class  tagMCShopItemDayBuyCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemIndex", c_int),    
                  ("BuyCnt", c_ushort),    # ½ñÈÕÒѹºÂò´ÎÊý
                  ("IsReset", c_ubyte),    #ÊÇ·ñÖØÖÃ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemIndex = 0
        self.BuyCnt = 0
        self.IsReset = 0
        return

    def GetLength(self):
        return sizeof(tagMCShopItemDayBuyCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// A8 02 ֪ͨNPCÉ̵êÎïÆ·½ñÈÕÒѹºÂò´ÎÊý //tagMCShopItemDayBuyCntInfo:
                                ItemIndex:%d,
                                BuyCnt:%d,
                                IsReset:%d
                                '''\
                                %(
                                self.ItemIndex,
                                self.BuyCnt,
                                self.IsReset
                                )
        return DumpString


class  tagMCShopItemDayBuyCntInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)//֪ͨ¸öÊý£¬×¢Òâ²»ÏÞÖÆÿÈÕ¹ºÂò´ÎÊýµÄĬÈϲ»Í¨Öª
    DayBuyCntList = list()    #(vector<tagMCShopItemDayBuyCnt> DayBuyCntList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x02
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temDayBuyCntList = tagMCShopItemDayBuyCnt()
            _pos = temDayBuyCntList.ReadData(_lpData, _pos)
            self.DayBuyCntList.append(temDayBuyCntList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x02
        self.Count = 0
        self.DayBuyCntList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.DayBuyCntList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.DayBuyCntList[i].GetLength(), self.DayBuyCntList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                DayBuyCntList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCShopItemDayBuyCntInfo=tagMCShopItemDayBuyCntInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShopItemDayBuyCntInfo.Head.Cmd,m_NAtagMCShopItemDayBuyCntInfo.Head.SubCmd))] = m_NAtagMCShopItemDayBuyCntInfo


#------------------------------------------------------
# A8 13 ÐéÄâµôÂäÎïÆ· #tagMCVirtualItemDrop

class  tagMCVirtualItemDrop(Structure):
    Head = tagHead()
    ItemTypeID = 0    #(DWORD ItemTypeID)
    PosX = 0    #(WORD PosX)
    PosY = 0    #(WORD PosY)
    UserDataLen = 0    #(WORD UserDataLen)//¸½¼ÓÊôÐÔ³¤¶È
    UserData = ""    #(String UserData)//¸½¼ÓÊôÐÔ  size = UserDataLen
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ItemTypeID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xA8
        self.Head.SubCmd = 0x13
        self.ItemTypeID = 0
        self.PosX = 0
        self.PosY = 0
        self.UserDataLen = 0
        self.UserData = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 2
        length += 2
        length += len(self.UserData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ItemTypeID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ItemTypeID:%d,
                                PosX:%d,
                                PosY:%d,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ItemTypeID,
                                self.PosX,
                                self.PosY,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString


m_NAtagMCVirtualItemDrop=tagMCVirtualItemDrop()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCVirtualItemDrop.Head.Cmd,m_NAtagMCVirtualItemDrop.Head.SubCmd))] = m_NAtagMCVirtualItemDrop


#------------------------------------------------------
# AA 67 BossÀúÁ·»î¶¯ÐÅÏ¢ #tagMCActBossTrialInfo

class  tagMCActBossTrialItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActBossTrialItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 67 BossÀúÁ·»î¶¯ÐÅÏ¢ //tagMCActBossTrialInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActBossTrialAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActBossTrialItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActBossTrialBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// ½±ÀøÎïÆ·ÁÐ±í£¬µ±ÏÉÃË°ñʱ£¬Èç¹ûÓиý±ÀøÔò´ú±íÃËÖ÷½±Àø£¬·ñÔòĬÈϾùΪ³ÉÔ±½±Àø
    MemCount = 0    #(BYTE MemCount)// ³ÉÔ±½±ÀøÎïÆ·Êý
    MemAwardItemList = list()    #(vector<tagMCActBossTrialItem> MemAwardItemList)// ³ÉÔ±½±ÀøÎïÆ·ÁÐ±í£¬½öÏÉÃË°ñʱÓÐЧ
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCActBossTrialAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActBossTrialItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MemCount):
            temMemAwardItemList = tagMCActBossTrialItem()
            _pos = temMemAwardItemList.ReadData(_lpData, _pos)
            self.MemAwardItemList.append(temMemAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCActBossTrialAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.MemCount = 0
        self.MemAwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 1
        for i in range(self.MemCount):
            length += self.MemAwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.MemCount)
        for i in range(self.MemCount):
            data = CommFunc.WriteString(data, self.MemAwardItemList[i].GetLength(), self.MemAwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                MemCount:%d,
                                MemAwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.MemCount,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCActBossTrialSubmitInfo(Structure):
    RecordIndex = 0    #(BYTE RecordIndex)// ¼Ç¼Ë÷Òý
    NeedCount = 0    #(WORD NeedCount)// ËùÐèÌá½»¸öÊý
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.RecordIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActBossTrialItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.RecordIndex = 0
        self.NeedCount = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.RecordIndex)
        data = CommFunc.WriteWORD(data, self.NeedCount)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                RecordIndex:%d,
                                NeedCount:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.RecordIndex,
                                self.NeedCount,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActBossTrialInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ShopType = 0    #(WORD ShopType)// ¿ª·ÅÉ̵êÀàÐÍ£¬¿ÉÄÜΪ0²»¿ª·Å
    SubResetType = 0    #(BYTE SubResetType)// Ìύƾ֤½±ÀøÖØÖÃÀàÐÍ£¬0-¸úËæ»î¶¯£» 1-0µãÖØÖã»2-5µãÖØÖÃ
    SubmitCount = 0    #(BYTE SubmitCount)
    SubmitInfoList = list()    #(vector<tagMCActBossTrialSubmitInfo> SubmitInfoList)// Ìύƾ֤ÐÅÏ¢Áбí
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCActBossTrialBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    FamilyBillCount = 0    #(BYTE FamilyBillCount)
    FamilyBillboardInfoList = list()    #(vector<tagMCActBossTrialBillard> FamilyBillboardInfoList)// ÏÉÃË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x67
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.SubResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SubmitCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SubmitCount):
            temSubmitInfoList = tagMCActBossTrialSubmitInfo()
            _pos = temSubmitInfoList.ReadData(_lpData, _pos)
            self.SubmitInfoList.append(temSubmitInfoList)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCActBossTrialBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        self.FamilyBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FamilyBillCount):
            temFamilyBillboardInfoList = tagMCActBossTrialBillard()
            _pos = temFamilyBillboardInfoList.ReadData(_lpData, _pos)
            self.FamilyBillboardInfoList.append(temFamilyBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x67
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.ShopType = 0
        self.SubResetType = 0
        self.SubmitCount = 0
        self.SubmitInfoList = list()
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        self.FamilyBillCount = 0
        self.FamilyBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        length += 1
        length += 2
        length += 2
        length += 1
        length += 1
        for i in range(self.SubmitCount):
            length += self.SubmitInfoList[i].GetLength()
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[i].GetLength()
        length += 1
        for i in range(self.FamilyBillCount):
            length += self.FamilyBillboardInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteWORD(data, self.ShopType)
        data = CommFunc.WriteBYTE(data, self.SubResetType)
        data = CommFunc.WriteBYTE(data, self.SubmitCount)
        for i in range(self.SubmitCount):
            data = CommFunc.WriteString(data, self.SubmitInfoList[i].GetLength(), self.SubmitInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FamilyBillCount)
        for i in range(self.FamilyBillCount):
            data = CommFunc.WriteString(data, self.FamilyBillboardInfoList[i].GetLength(), self.FamilyBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                ShopType:%d,
                                SubResetType:%d,
                                SubmitCount:%d,
                                SubmitInfoList:%s,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s,
                                FamilyBillCount:%d,
                                FamilyBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.ShopType,
                                self.SubResetType,
                                self.SubmitCount,
                                "...",
                                self.PersonalBillCount,
                                "...",
                                self.FamilyBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActBossTrialInfo=tagMCActBossTrialInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBossTrialInfo.Head.Cmd,m_NAtagMCActBossTrialInfo.Head.SubCmd))] = m_NAtagMCActBossTrialInfo


#------------------------------------------------------
# AA 68 BossÀúÁ·»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActBossTrialPlayerInfo

class  tagMCActBossTrialPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("SubmitCount", c_int),    # ÒÑÌύƾ֤¸öÊý£¬×ܸöÊý
                  ("SubmitAwardCount", c_int),    # ÒÑÌύƾ֤¸öÊý£¬¹ØÁªÌá½»½±ÀøµÄ¸öÊý£¬Á콱ʹÓøøöÊýÅжÏ
                  ("SubmitAwardState", c_int),    # Ìύƾ֤½±ÀøÁ콱״̬
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x68
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x68
        self.ActNum = 0
        self.SubmitCount = 0
        self.SubmitAwardCount = 0
        self.SubmitAwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCActBossTrialPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 68 BossÀúÁ·»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActBossTrialPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                SubmitCount:%d,
                                SubmitAwardCount:%d,
                                SubmitAwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.SubmitCount,
                                self.SubmitAwardCount,
                                self.SubmitAwardState
                                )
        return DumpString


m_NAtagMCActBossTrialPlayerInfo=tagMCActBossTrialPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBossTrialPlayerInfo.Cmd,m_NAtagMCActBossTrialPlayerInfo.SubCmd))] = m_NAtagMCActBossTrialPlayerInfo


#------------------------------------------------------
# AA 74 ¹ºÂò´ÎÊýÀñ°ü»î¶¯ÐÅÏ¢ #tagMCActBuyCountGiftInfo

class  tagMCActBuyCountGiftItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActBuyCountGiftItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 74 ¹ºÂò´ÎÊýÀñ°ü»î¶¯ÐÅÏ¢ //tagMCActBuyCountGiftInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActBuyCountGift(Structure):
    NeedBuyCount = 0    #(BYTE NeedBuyCount)// ËùÐè×ܹºÂò´ÎÊý£¬0ΪÃâ·ÑÁìÈ¡µÄµµ´Î
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActBuyCountGiftItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedBuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActBuyCountGiftItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedBuyCount = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NeedBuyCount)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedBuyCount:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedBuyCount,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActBuyCountGiftInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    CTGIDCount = 0    #(BYTE CTGIDCount)
    CTGIDList = list()    #(vector<WORD> CTGIDList)// CTGIDÁÐ±í£»×ܹºÂò´ÎÊýÇ°¶Ë×Ô¼ºÍ³¼Æ£¬Ö±½ÓÈ¡CTGID¶ÔÓ¦µÄÀۼƹºÂò´ÎÊýÀÛ¼Ó
    GiftCount = 0    #(BYTE GiftCount)
    BuyCountGiftList = list()    #(vector<tagMCActBuyCountGift> BuyCountGiftList)// ¹ºÂò´ÎÊýÀñ°üÁбí
    ShopType = 0    #(WORD ShopType)// ¿ª·ÅÉ̵êÀàÐÍ£¬¿ÉÄÜΪ0²»¿ª·Å
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x74
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.CTGIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CTGIDCount):
            value,_pos=CommFunc.ReadWORD(_lpData,_pos)
            self.CTGIDList.append(value)
        self.GiftCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftCount):
            temBuyCountGiftList = tagMCActBuyCountGift()
            _pos = temBuyCountGiftList.ReadData(_lpData, _pos)
            self.BuyCountGiftList.append(temBuyCountGiftList)
        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x74
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.CTGIDCount = 0
        self.CTGIDList = list()
        self.GiftCount = 0
        self.BuyCountGiftList = list()
        self.ShopType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 1
        length += 2
        length += 1
        length += 2 * self.CTGIDCount
        length += 1
        for i in range(self.GiftCount):
            length += self.BuyCountGiftList[i].GetLength()
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.CTGIDCount)
        for i in range(self.CTGIDCount):
            data = CommFunc.WriteWORD(data, self.CTGIDList[i])
        data = CommFunc.WriteBYTE(data, self.GiftCount)
        for i in range(self.GiftCount):
            data = CommFunc.WriteString(data, self.BuyCountGiftList[i].GetLength(), self.BuyCountGiftList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.ShopType)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                CTGIDCount:%d,
                                CTGIDList:%s,
                                GiftCount:%d,
                                BuyCountGiftList:%s,
                                ShopType:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.CTGIDCount,
                                "...",
                                self.GiftCount,
                                "...",
                                self.ShopType
                                )
        return DumpString


m_NAtagMCActBuyCountGiftInfo=tagMCActBuyCountGiftInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBuyCountGiftInfo.Head.Cmd,m_NAtagMCActBuyCountGiftInfo.Head.SubCmd))] = m_NAtagMCActBuyCountGiftInfo


#------------------------------------------------------
# AA 75 ¹ºÂò´ÎÊýÀñ°ü»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActBuyCountGiftPlayerInfo

class  tagMCActBuyCountGiftPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("GiftAwardRecord", c_int),    # ¹ºÂò´ÎÊýÀñ°üÁì½±¼Ç¼£¬Ö±½ÓÓùºÂò´ÎÊý×öλÔËËãÅжÏÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x75
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x75
        self.ActNum = 0
        self.GiftAwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCActBuyCountGiftPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 75 ¹ºÂò´ÎÊýÀñ°ü»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActBuyCountGiftPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                GiftAwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.GiftAwardRecord
                                )
        return DumpString


m_NAtagMCActBuyCountGiftPlayerInfo=tagMCActBuyCountGiftPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBuyCountGiftPlayerInfo.Cmd,m_NAtagMCActBuyCountGiftPlayerInfo.SubCmd))] = m_NAtagMCActBuyCountGiftPlayerInfo


#------------------------------------------------------
# AA 65 ÂòÒ»ËͶà»î¶¯ÐÅÏ¢ #tagMCActBuyOneInfo

class  tagMCActBuyOneInfoFreeItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActBuyOneInfoFreeItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 65 ÂòÒ»ËͶà»î¶¯ÐÅÏ¢ //tagMCActBuyOneInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActBuyOneInfoFreeGift(Structure):
    FreeIndex = 0    #(BYTE FreeIndex)// Ãâ·ÑÁìÈ¡Ë÷Òý
    FreeItemCount = 0    #(BYTE FreeItemCount)// Ãâ·ÑÀñ°üÊý
    FreeItemList = list()    #(vector<tagMCActBuyOneInfoFreeItem> FreeItemList)// Ãâ·ÑÀñ°üÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.FreeIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FreeItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FreeItemCount):
            temFreeItemList = tagMCActBuyOneInfoFreeItem()
            _pos = temFreeItemList.ReadData(_lpData, _pos)
            self.FreeItemList.append(temFreeItemList)
        return _pos

    def Clear(self):
        self.FreeIndex = 0
        self.FreeItemCount = 0
        self.FreeItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        for i in range(self.FreeItemCount):
            length += self.FreeItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.FreeIndex)
        data = CommFunc.WriteBYTE(data, self.FreeItemCount)
        for i in range(self.FreeItemCount):
            data = CommFunc.WriteString(data, self.FreeItemList[i].GetLength(), self.FreeItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                FreeIndex:%d,
                                FreeItemCount:%d,
                                FreeItemList:%s
                                '''\
                                %(
                                self.FreeIndex,
                                self.FreeItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActBuyOneInfoGiftbag(Structure):
    CTGID = 0    #(DWORD CTGID)//ËùÐè³äÖµID
    RecordIndex = 0    #(BYTE RecordIndex)// ¼Ç¼Ë÷Òý
    FreeGiftCount = 0    #(BYTE FreeGiftCount)// Ãâ·ÑÀñ°üÊý
    FreeGiftList = list()    #(vector<tagMCActBuyOneInfoFreeGift> FreeGiftList)// Ãâ·ÑÀñ°üÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.CTGID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RecordIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FreeGiftCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FreeGiftCount):
            temFreeGiftList = tagMCActBuyOneInfoFreeGift()
            _pos = temFreeGiftList.ReadData(_lpData, _pos)
            self.FreeGiftList.append(temFreeGiftList)
        return _pos

    def Clear(self):
        self.CTGID = 0
        self.RecordIndex = 0
        self.FreeGiftCount = 0
        self.FreeGiftList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += 1
        for i in range(self.FreeGiftCount):
            length += self.FreeGiftList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.CTGID)
        data = CommFunc.WriteBYTE(data, self.RecordIndex)
        data = CommFunc.WriteBYTE(data, self.FreeGiftCount)
        for i in range(self.FreeGiftCount):
            data = CommFunc.WriteString(data, self.FreeGiftList[i].GetLength(), self.FreeGiftList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                CTGID:%d,
                                RecordIndex:%d,
                                FreeGiftCount:%d,
                                FreeGiftList:%s
                                '''\
                                %(
                                self.CTGID,
                                self.RecordIndex,
                                self.FreeGiftCount,
                                "..."
                                )
        return DumpString


class  tagMCActBuyOneInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    GiftbagCount = 0    #(BYTE GiftbagCount)// »î¶¯Àñ°ü¸öÊý
    GiftbagList = list()    #(vector<tagMCActBuyOneInfoGiftbag> GiftbagList)// Àñ°üÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x65
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagList = tagMCActBuyOneInfoGiftbag()
            _pos = temGiftbagList.ReadData(_lpData, _pos)
            self.GiftbagList.append(temGiftbagList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x65
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.GiftbagCount = 0
        self.GiftbagList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagList[i].GetLength(), self.GiftbagList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                GiftbagCount:%d,
                                GiftbagList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActBuyOneInfo=tagMCActBuyOneInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBuyOneInfo.Head.Cmd,m_NAtagMCActBuyOneInfo.Head.SubCmd))] = m_NAtagMCActBuyOneInfo


#------------------------------------------------------
# AA 66 ÂòÒ»ËͶà»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActBuyOnePlayerInfo

class  tagMCActBuyOnePlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    FreeRecordCount = 0    #(BYTE FreeRecordCount)// Ãâ·ÑÀñ°üÁì½±¼Ç¼¸öÊý
    FreeRecordList = list()    #(vector<DWORD> FreeRecordList)// Ãâ·ÑÀñ°üÁì½±¼Ç¼ÁÐ±í£¬°´ËùÐè³äÖµID¼Ç¼Ë÷ÒýÈ¡¼Ç¼£¬Ã¿¸ö¼Ç¼´ú±íÿ¸ö³äÖµID¶ÔÓ¦Ãâ·ÑÀñ°üµÄÁìÈ¡¼Ç¼£¬°´Ãâ·ÑÁìÈ¡Ë÷ÒýλÔËËã¼Ç¼ÊÇ·ñÒÑÁìÈ¡
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x66
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FreeRecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FreeRecordCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.FreeRecordList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x66
        self.ActNum = 0
        self.FreeRecordCount = 0
        self.FreeRecordList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4 * self.FreeRecordCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.FreeRecordCount)
        for i in range(self.FreeRecordCount):
            data = CommFunc.WriteDWORD(data, self.FreeRecordList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                FreeRecordCount:%d,
                                FreeRecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.FreeRecordCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActBuyOnePlayerInfo=tagMCActBuyOnePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBuyOnePlayerInfo.Head.Cmd,m_NAtagMCActBuyOnePlayerInfo.Head.SubCmd))] = m_NAtagMCActBuyOnePlayerInfo


#------------------------------------------------------
# AA 40 ¼¯×ֻÐÅÏ¢ #tagMCActCollectWordsInfo

class  tagMCActCollectWordsNeedItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActCollectWordsNeedItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 40 ¼¯×ֻÐÅÏ¢ //tagMCActCollectWordsInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActCollectWordsExchangeItem(Structure):
    ExchangeNum = 0    #(BYTE ExchangeNum)//¶Ò»»±àºÅ
    ExchangeCountMax = 0    #(WORD ExchangeCountMax)//×î´ó¶Ò»»´ÎÊý£¬0²»ÏÞÖÆ
    ItemID = 0    #(DWORD ItemID)//Ä¿±êÎïÆ·
    ItemCount = 0    #(WORD ItemCount)
    IsBind = 0    #(BYTE IsBind)
    NeedItemCount = 0    #(BYTE NeedItemCount)
    NeedItemList = list()    #(vector<tagMCActCollectWordsNeedItem> NeedItemList)// ËùÐèÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ExchangeNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExchangeCountMax,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsBind,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.NeedItemCount):
            temNeedItemList = tagMCActCollectWordsNeedItem()
            _pos = temNeedItemList.ReadData(_lpData, _pos)
            self.NeedItemList.append(temNeedItemList)
        return _pos

    def Clear(self):
        self.ExchangeNum = 0
        self.ExchangeCountMax = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        self.NeedItemCount = 0
        self.NeedItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 4
        length += 2
        length += 1
        length += 1
        for i in range(self.NeedItemCount):
            length += self.NeedItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ExchangeNum)
        data = CommFunc.WriteWORD(data, self.ExchangeCountMax)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.ItemCount)
        data = CommFunc.WriteBYTE(data, self.IsBind)
        data = CommFunc.WriteBYTE(data, self.NeedItemCount)
        for i in range(self.NeedItemCount):
            data = CommFunc.WriteString(data, self.NeedItemList[i].GetLength(), self.NeedItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                ExchangeNum:%d,
                                ExchangeCountMax:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d,
                                NeedItemCount:%d,
                                NeedItemList:%s
                                '''\
                                %(
                                self.ExchangeNum,
                                self.ExchangeCountMax,
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind,
                                self.NeedItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActCollectWordsInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ£¬1 »ò 2£¬Ï໥¶ÀÁ¢µÄ»î¶¯£¬¿Éͬʱ¿ªÆô
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    LastDayOnlyExchange = 0    #(BYTE LastDayOnlyExchange)//×îºóÒ»ÌìÊÇ·ñ½ö¶Ò»»
    ExchangeCount = 0    #(BYTE ExchangeCount)
    ExchangeItemList = list()    #(vector<tagMCActCollectWordsExchangeItem> ExchangeItemList)//¶Ò»»×éºÏÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x40
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LastDayOnlyExchange,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExchangeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ExchangeCount):
            temExchangeItemList = tagMCActCollectWordsExchangeItem()
            _pos = temExchangeItemList.ReadData(_lpData, _pos)
            self.ExchangeItemList.append(temExchangeItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x40
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.LastDayOnlyExchange = 0
        self.ExchangeCount = 0
        self.ExchangeItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        for i in range(self.ExchangeCount):
            length += self.ExchangeItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.LastDayOnlyExchange)
        data = CommFunc.WriteBYTE(data, self.ExchangeCount)
        for i in range(self.ExchangeCount):
            data = CommFunc.WriteString(data, self.ExchangeItemList[i].GetLength(), self.ExchangeItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                LastDayOnlyExchange:%d,
                                ExchangeCount:%d,
                                ExchangeItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.LastDayOnlyExchange,
                                self.ExchangeCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActCollectWordsInfo=tagMCActCollectWordsInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActCollectWordsInfo.Head.Cmd,m_NAtagMCActCollectWordsInfo.Head.SubCmd))] = m_NAtagMCActCollectWordsInfo


#------------------------------------------------------
# AA 41 ¼¯×ֻÍæ¼ÒÐÅÏ¢ #tagMCActCollectWordsPlayerInfo

class  tagMCActCollectWordsExchangeInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ExchangeNum", c_ubyte),    #¶Ò»»±àºÅ
                  ("ExchangeCount", 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.ExchangeNum = 0
        self.ExchangeCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCActCollectWordsExchangeInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 41 ¼¯×ֻÍæ¼ÒÐÅÏ¢ //tagMCActCollectWordsPlayerInfo:
                                ExchangeNum:%d,
                                ExchangeCount:%d
                                '''\
                                %(
                                self.ExchangeNum,
                                self.ExchangeCount
                                )
        return DumpString


class  tagMCActCollectWordsPlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ£¬1 »ò 2£¬Ï໥¶ÀÁ¢µÄ»î¶¯£¬¿Éͬʱ¿ªÆô
    ExchangeCount = 0    #(BYTE ExchangeCount)
    ExchangeInfoList = list()    #(vector<tagMCActCollectWordsExchangeInfo> ExchangeInfoList)//¶Ò»»Êý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x41
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExchangeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ExchangeCount):
            temExchangeInfoList = tagMCActCollectWordsExchangeInfo()
            _pos = temExchangeInfoList.ReadData(_lpData, _pos)
            self.ExchangeInfoList.append(temExchangeInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x41
        self.ActNum = 0
        self.ExchangeCount = 0
        self.ExchangeInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.ExchangeCount):
            length += self.ExchangeInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.ExchangeCount)
        for i in range(self.ExchangeCount):
            data = CommFunc.WriteString(data, self.ExchangeInfoList[i].GetLength(), self.ExchangeInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                ExchangeCount:%d,
                                ExchangeInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.ExchangeCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActCollectWordsPlayerInfo=tagMCActCollectWordsPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActCollectWordsPlayerInfo.Head.Cmd,m_NAtagMCActCollectWordsPlayerInfo.Head.SubCmd))] = m_NAtagMCActCollectWordsPlayerInfo


#------------------------------------------------------
# AA 77 ÏÉÃ˳äÖµ»¥Öú»î¶¯ÐÅÏ¢ #tagMCActFamilyCTGAssistInfo

class  tagMCActFamilyCTGAssistItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActFamilyCTGAssistItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 77 ÏÉÃ˳äÖµ»¥Öú»î¶¯ÐÅÏ¢ //tagMCActFamilyCTGAssistInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActFamilyCTGAssistAward(Structure):
    NeedCTGPlayers = 0    #(BYTE NeedCTGPlayers)//ËùÐè³äÖµÈËÊý
    RecordIndex = 0    #(BYTE RecordIndex)//¶ÔÓ¦Áì½±¼Ç¼Ë÷Òý
    Count = 0    #(BYTE Count)
    AwardItemList = list()    #(vector<tagMCActFamilyCTGAssistItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedCTGPlayers,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RecordIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActFamilyCTGAssistItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedCTGPlayers = 0
        self.RecordIndex = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.NeedCTGPlayers)
        data = CommFunc.WriteBYTE(data, self.RecordIndex)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedCTGPlayers:%d,
                                RecordIndex:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedCTGPlayers,
                                self.RecordIndex,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActFamilyCTGAssistInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AwardCount = 0    #(BYTE AwardCount)
    AwardInfoList = list()    #(vector<tagMCActFamilyCTGAssistAward> AwardInfoList)// »¥Öú½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x77
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardInfoList = tagMCActFamilyCTGAssistAward()
            _pos = temAwardInfoList.ReadData(_lpData, _pos)
            self.AwardInfoList.append(temAwardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x77
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.AwardCount = 0
        self.AwardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardInfoList[i].GetLength(), self.AwardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                AwardCount:%d,
                                AwardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActFamilyCTGAssistInfo=tagMCActFamilyCTGAssistInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActFamilyCTGAssistInfo.Head.Cmd,m_NAtagMCActFamilyCTGAssistInfo.Head.SubCmd))] = m_NAtagMCActFamilyCTGAssistInfo


#------------------------------------------------------
# AA 78 ÏÉÃ˳äÖµ»¥Öú»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActFamilyCTGAssistPlayerInfo

class  tagMCActFamilyCTGAssistPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("AwardRecord", c_int),    # ½±Àø¼Ç¼£¬°´½±Àø¼Ç¼Ë÷ÒýλÔËËãÅжÏÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x78
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x78
        self.ActNum = 0
        self.AwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCActFamilyCTGAssistPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 78 ÏÉÃ˳äÖµ»¥Öú»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActFamilyCTGAssistPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                AwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.AwardRecord
                                )
        return DumpString


m_NAtagMCActFamilyCTGAssistPlayerInfo=tagMCActFamilyCTGAssistPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActFamilyCTGAssistPlayerInfo.Cmd,m_NAtagMCActFamilyCTGAssistPlayerInfo.SubCmd))] = m_NAtagMCActFamilyCTGAssistPlayerInfo


#------------------------------------------------------
# AA 55 À¬»øÊÕ¼¯»î¶¯ÐÅÏ¢ #tagMCActGarbageSortingInfo

class  tagMCActGarbageSortingInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µã¿ª£¬5µãÖØÖã»2-5µã¿ª£¬0µãÖØÖÃ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x55
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x55
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.ResetType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                ResetType:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.ResetType
                                )
        return DumpString


m_NAtagMCActGarbageSortingInfo=tagMCActGarbageSortingInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageSortingInfo.Head.Cmd,m_NAtagMCActGarbageSortingInfo.Head.SubCmd))] = m_NAtagMCActGarbageSortingInfo


#------------------------------------------------------
# AA 57 À¬»øÊÕ¼¯»î¶¯·ÖÀà½á¹û #tagMCActGarbageSortingResult

class  tagMCActGarbageSortingResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    #»î¶¯±àºÅ
                  ("GarbageSortingType", c_ubyte),    #À¬»ø·ÖÀàÀàÐÍ
                  ("IsRight", c_ubyte),    #ÊÇ·ñÕýÈ·
                  ("AddEnvValue", c_int),    #Ôö¼Ó»·±£Öµ
                  ("HisEnvValueTotal", c_int),    # µ±Ç°»î¶¯ÀۼƻñµÃ»·±£Öµ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x57
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x57
        self.ActNum = 0
        self.GarbageSortingType = 0
        self.IsRight = 0
        self.AddEnvValue = 0
        self.HisEnvValueTotal = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGarbageSortingResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 57 À¬»øÊÕ¼¯»î¶¯·ÖÀà½á¹û //tagMCActGarbageSortingResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                GarbageSortingType:%d,
                                IsRight:%d,
                                AddEnvValue:%d,
                                HisEnvValueTotal:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.GarbageSortingType,
                                self.IsRight,
                                self.AddEnvValue,
                                self.HisEnvValueTotal
                                )
        return DumpString


m_NAtagMCActGarbageSortingResult=tagMCActGarbageSortingResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageSortingResult.Cmd,m_NAtagMCActGarbageSortingResult.SubCmd))] = m_NAtagMCActGarbageSortingResult


#------------------------------------------------------
# AA 56 À¬»øÊÕ¼¯»î¶¯ÈÎÎñ½ø¶ÈÐÅÏ¢ #tagMCActGarbageTaskInfo

class  tagMCActGarbageTask(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GarbageTaskID", c_ubyte),    #À¬»øÈÎÎñID
                  ("GarbageTaskValue", c_int),    #µ±Ç°½ø¶ÈÖµ£¬Ò»Ö±ÀÛ¼Ó
                  ("GarbageTaskFinishCount", c_int),    #µ±Ç°ÒÑÍê³É´ÎÊý; Ç°¶Ë¼ÆËãδÍê³É´ÎÊýµÄ½ø¶ÈÖµ=max(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.GarbageTaskID = 0
        self.GarbageTaskValue = 0
        self.GarbageTaskFinishCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGarbageTask)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 56 À¬»øÊÕ¼¯»î¶¯ÈÎÎñ½ø¶ÈÐÅÏ¢ //tagMCActGarbageTaskInfo:
                                GarbageTaskID:%d,
                                GarbageTaskValue:%d,
                                GarbageTaskFinishCount:%d
                                '''\
                                %(
                                self.GarbageTaskID,
                                self.GarbageTaskValue,
                                self.GarbageTaskFinishCount
                                )
        return DumpString


class  tagMCActGarbageTaskInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    HisEnvValueTotal = 0    #(DWORD HisEnvValueTotal)// µ±Ç°»î¶¯ÀۼƻñµÃ»·±£Öµ
    GarbageTaskCount = 0    #(BYTE GarbageTaskCount)//ÈÎÎñÊý
    GarbageTaskList = list()    #(vector<tagMCActGarbageTask> GarbageTaskList)//ÈÎÎñÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x56
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HisEnvValueTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GarbageTaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GarbageTaskCount):
            temGarbageTaskList = tagMCActGarbageTask()
            _pos = temGarbageTaskList.ReadData(_lpData, _pos)
            self.GarbageTaskList.append(temGarbageTaskList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x56
        self.ActNum = 0
        self.HisEnvValueTotal = 0
        self.GarbageTaskCount = 0
        self.GarbageTaskList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 4
        length += 1
        for i in range(self.GarbageTaskCount):
            length += self.GarbageTaskList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteDWORD(data, self.HisEnvValueTotal)
        data = CommFunc.WriteBYTE(data, self.GarbageTaskCount)
        for i in range(self.GarbageTaskCount):
            data = CommFunc.WriteString(data, self.GarbageTaskList[i].GetLength(), self.GarbageTaskList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                HisEnvValueTotal:%d,
                                GarbageTaskCount:%d,
                                GarbageTaskList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.HisEnvValueTotal,
                                self.GarbageTaskCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActGarbageTaskInfo=tagMCActGarbageTaskInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageTaskInfo.Head.Cmd,m_NAtagMCActGarbageTaskInfo.Head.SubCmd))] = m_NAtagMCActGarbageTaskInfo


#------------------------------------------------------
# AA 60 ÌìµÛÀñ°ü»î¶¯ÐÅÏ¢ #tagMCActGodGiftInfo

class  tagMCActGodGiftItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemNum", c_ubyte),    # ÎïÆ·ÔÚ±¾¿âÖеıàºÅ
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ("CanChooseTimes", c_ubyte),    #¿ÉÑ¡Ôñ´ÎÊý£¬0´ú±í²»ÏÞ´ÎÊý
                  ("ChooseTimes", c_ubyte),    #ÒÑÑ¡´ÎÊý
                  ("IsChoose", c_ubyte),    #±¾´Î½±³ØÊÇ·ñ±»Ñ¡Ôñ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemNum = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        self.CanChooseTimes = 0
        self.ChooseTimes = 0
        self.IsChoose = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGodGiftItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 60 ÌìµÛÀñ°ü»î¶¯ÐÅÏ¢ //tagMCActGodGiftInfo:
                                ItemNum:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d,
                                CanChooseTimes:%d,
                                ChooseTimes:%d,
                                IsChoose:%d
                                '''\
                                %(
                                self.ItemNum,
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind,
                                self.CanChooseTimes,
                                self.ChooseTimes,
                                self.IsChoose
                                )
        return DumpString


class  tagMCActGodGiftItemLib(Structure):
    ItemLibType = 0    #(BYTE ItemLibType)//ÎïÆ·¿âÀàÐÍ
    NeedChooseCount = 0    #(BYTE NeedChooseCount)//ÐèҪѡÔñ¸öÊý
    GodGiftItemCount = 0    #(BYTE GodGiftItemCount)//¿ÉÑ¡ÔñÎïÆ·¸öÊý
    GodGiftItemList = list()    #(vector<tagMCActGodGiftItem> GodGiftItemList)//¿ÉÑ¡ÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemLibType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GodGiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GodGiftItemCount):
            temGodGiftItemList = tagMCActGodGiftItem()
            _pos = temGodGiftItemList.ReadData(_lpData, _pos)
            self.GodGiftItemList.append(temGodGiftItemList)
        return _pos

    def Clear(self):
        self.ItemLibType = 0
        self.NeedChooseCount = 0
        self.GodGiftItemCount = 0
        self.GodGiftItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        for i in range(self.GodGiftItemCount):
            length += self.GodGiftItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ItemLibType)
        data = CommFunc.WriteBYTE(data, self.NeedChooseCount)
        data = CommFunc.WriteBYTE(data, self.GodGiftItemCount)
        for i in range(self.GodGiftItemCount):
            data = CommFunc.WriteString(data, self.GodGiftItemList[i].GetLength(), self.GodGiftItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                ItemLibType:%d,
                                NeedChooseCount:%d,
                                GodGiftItemCount:%d,
                                GodGiftItemList:%s
                                '''\
                                %(
                                self.ItemLibType,
                                self.NeedChooseCount,
                                self.GodGiftItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActGodGiftInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÈÕÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    CostMoneyType = 0    #(BYTE CostMoneyType)//ÏûºÄ»õ±ÒÀàÐÍ
    CostMoneyValueCount = 0    #(BYTE CostMoneyValueCount)
    CostMoneyValueList = list()    #(vector<DWORD> CostMoneyValueList)//ÏûºÄ»õ±ÒÖµÁбí
    PrizeMoneyType = 0    #(BYTE PrizeMoneyType)//½±Àø»õ±ÒÀàÐÍ
    PrizeMoneyValueCount = 0    #(BYTE PrizeMoneyValueCount)
    PrizeMoneyValueList = list()    #(vector<DWORD> PrizeMoneyValueList)//½±Àø»õ±ÒÖµÁбí
    ResetLimitTimes = 0    #(BYTE ResetLimitTimes)//ÖÁÉٳ鼸´Î²Å¿ÉÖØÖý±³Ø
    ResetCountMax = 0    #(BYTE ResetCountMax)//×î´ó¿ÉÖØÖý±³Ø´ÎÊý
    IsAwardPoolOK = 0    #(BYTE IsAwardPoolOK)//½±³ØÊÇ·ñÑ¡ÔñÍê±Ï£¬·ñµÄ»°ÐèÒªÏÈÑ¡Ôñ½±³Ø²Å¿É³é½±
    ItemLibCount = 0    #(BYTE ItemLibCount)//½±³Ø¿â¸öÊý	
    ItemLibList = list()    #(vector<tagMCActGodGiftItemLib> ItemLibList)//½±³Ø¿âÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x60
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.CostMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CostMoneyValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CostMoneyValueCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.CostMoneyValueList.append(value)
        self.PrizeMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PrizeMoneyValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PrizeMoneyValueCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.PrizeMoneyValueList.append(value)
        self.ResetLimitTimes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetCountMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsAwardPoolOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemLibCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ItemLibCount):
            temItemLibList = tagMCActGodGiftItemLib()
            _pos = temItemLibList.ReadData(_lpData, _pos)
            self.ItemLibList.append(temItemLibList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x60
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.CostMoneyType = 0
        self.CostMoneyValueCount = 0
        self.CostMoneyValueList = list()
        self.PrizeMoneyType = 0
        self.PrizeMoneyValueCount = 0
        self.PrizeMoneyValueList = list()
        self.ResetLimitTimes = 0
        self.ResetCountMax = 0
        self.IsAwardPoolOK = 0
        self.ItemLibCount = 0
        self.ItemLibList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        length += 1
        length += 4 * self.CostMoneyValueCount
        length += 1
        length += 1
        length += 4 * self.PrizeMoneyValueCount
        length += 1
        length += 1
        length += 1
        length += 1
        for i in range(self.ItemLibCount):
            length += self.ItemLibList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.CostMoneyType)
        data = CommFunc.WriteBYTE(data, self.CostMoneyValueCount)
        for i in range(self.CostMoneyValueCount):
            data = CommFunc.WriteDWORD(data, self.CostMoneyValueList[i])
        data = CommFunc.WriteBYTE(data, self.PrizeMoneyType)
        data = CommFunc.WriteBYTE(data, self.PrizeMoneyValueCount)
        for i in range(self.PrizeMoneyValueCount):
            data = CommFunc.WriteDWORD(data, self.PrizeMoneyValueList[i])
        data = CommFunc.WriteBYTE(data, self.ResetLimitTimes)
        data = CommFunc.WriteBYTE(data, self.ResetCountMax)
        data = CommFunc.WriteBYTE(data, self.IsAwardPoolOK)
        data = CommFunc.WriteBYTE(data, self.ItemLibCount)
        for i in range(self.ItemLibCount):
            data = CommFunc.WriteString(data, self.ItemLibList[i].GetLength(), self.ItemLibList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                CostMoneyType:%d,
                                CostMoneyValueCount:%d,
                                CostMoneyValueList:%s,
                                PrizeMoneyType:%d,
                                PrizeMoneyValueCount:%d,
                                PrizeMoneyValueList:%s,
                                ResetLimitTimes:%d,
                                ResetCountMax:%d,
                                IsAwardPoolOK:%d,
                                ItemLibCount:%d,
                                ItemLibList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.CostMoneyType,
                                self.CostMoneyValueCount,
                                "...",
                                self.PrizeMoneyType,
                                self.PrizeMoneyValueCount,
                                "...",
                                self.ResetLimitTimes,
                                self.ResetCountMax,
                                self.IsAwardPoolOK,
                                self.ItemLibCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActGodGiftInfo=tagMCActGodGiftInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGodGiftInfo.Head.Cmd,m_NAtagMCActGodGiftInfo.Head.SubCmd))] = m_NAtagMCActGodGiftInfo


#------------------------------------------------------
# AA 61 ÌìµÛÀñ°ü»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActGodGiftPlayerInfo

class  tagMCActGodGiftAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemLibType", c_ubyte),    #ÎïÆ·¿âÀàÐÍ
                  ("ItemNum", c_ubyte),    #ÎïÆ·ÔÚ±¾¿âÖеıàºÅ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemLibType = 0
        self.ItemNum = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGodGiftAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 61 ÌìµÛÀñ°ü»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActGodGiftPlayerInfo:
                                ItemLibType:%d,
                                ItemNum:%d
                                '''\
                                %(
                                self.ItemLibType,
                                self.ItemNum
                                )
        return DumpString


class  tagMCActGodGiftPlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    ResetCount = 0    #(BYTE ResetCount)// ±¾´Î»î¶¯ÒÑÖØÖôÎÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)// ±¾´Î½±³ØÒѳéÖн±Æ·¸öÊý£¬Ò²´ú±í±¾´Î½±³ØÒѳ齱´ÎÊý
    AwardItemList = list()    #(vector<tagMCActGodGiftAwardItem> AwardItemList)// ±¾´Î½±³ØÒѳéÖÐÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x61
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCActGodGiftAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x61
        self.ActNum = 0
        self.ResetCount = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.ResetCount)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                ResetCount:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.ResetCount,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActGodGiftPlayerInfo=tagMCActGodGiftPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGodGiftPlayerInfo.Head.Cmd,m_NAtagMCActGodGiftPlayerInfo.Head.SubCmd))] = m_NAtagMCActGodGiftPlayerInfo


#------------------------------------------------------
# AA 31 ³É³¤±ØÂò»î¶¯ÐÅÏ¢ #tagMCActGrowupBuyInfo

class  tagMCActGrowupBuyCTGItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGrowupBuyCTGItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 31 ³É³¤±ØÂò»î¶¯ÐÅÏ¢ //tagMCActGrowupBuyInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActGrowupBuyCTGInfo(Structure):
    CTGID = 0    #(WORD CTGID)// ³äÖµ±íID
    GainItemCount = 0    #(BYTE GainItemCount)// »ñµÃÎïÆ·Êý
    GainItemList = list()    #(vector<tagMCActGrowupBuyCTGItem> GainItemList)// »ñµÃÎïÆ·ÁÐ±í£¬Ìæ»»³äÖµ±íÖÐµÄ GainItemList ×Ö¶ÎÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.CTGID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GainItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GainItemCount):
            temGainItemList = tagMCActGrowupBuyCTGItem()
            _pos = temGainItemList.ReadData(_lpData, _pos)
            self.GainItemList.append(temGainItemList)
        return _pos

    def Clear(self):
        self.CTGID = 0
        self.GainItemCount = 0
        self.GainItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 2
        length += 1
        for i in range(self.GainItemCount):
            length += self.GainItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteWORD(data, self.CTGID)
        data = CommFunc.WriteBYTE(data, self.GainItemCount)
        for i in range(self.GainItemCount):
            data = CommFunc.WriteString(data, self.GainItemList[i].GetLength(), self.GainItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                CTGID:%d,
                                GainItemCount:%d,
                                GainItemList:%s
                                '''\
                                %(
                                self.CTGID,
                                self.GainItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActGrowupBuyGroup(Structure):
    BuyCount = 0    #(BYTE BuyCount)// Ñ­»·¹ºÂòÀñ°üÊý
    BuyCTGIDList = list()    #(vector<tagMCActGrowupBuyCTGInfo> BuyCTGIDList)// Ñ­»·¹ºÂòÀñ°ü³äÖµIDÐÅÏ¢Áбí
    PlayerBuyIndex = 0    #(BYTE PlayerBuyIndex)// Íæ¼Òµ±Ç°¿É¹ºÂòµÄÀñ°ü³äÖµIDÔÚÁбíÖÐË÷Òý
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.BuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BuyCount):
            temBuyCTGIDList = tagMCActGrowupBuyCTGInfo()
            _pos = temBuyCTGIDList.ReadData(_lpData, _pos)
            self.BuyCTGIDList.append(temBuyCTGIDList)
        self.PlayerBuyIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.BuyCount = 0
        self.BuyCTGIDList = list()
        self.PlayerBuyIndex = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.BuyCount):
            length += self.BuyCTGIDList[i].GetLength()
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.BuyCount)
        for i in range(self.BuyCount):
            data = CommFunc.WriteString(data, self.BuyCTGIDList[i].GetLength(), self.BuyCTGIDList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PlayerBuyIndex)
        return data

    def OutputString(self):
        DumpString = '''
                                BuyCount:%d,
                                BuyCTGIDList:%s,
                                PlayerBuyIndex:%d
                                '''\
                                %(
                                self.BuyCount,
                                "...",
                                self.PlayerBuyIndex
                                )
        return DumpString


class  tagMCActGrowupBuyInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    GroupCount = 0    #(BYTE GroupCount)// Ñ­»·¹ºÂòÀñ°ü×éÊý
    GroupList = list()    #(vector<tagMCActGrowupBuyGroup> GroupList)//Ñ­»·¹ºÂòÀñ°ü×éÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x31
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GroupCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GroupCount):
            temGroupList = tagMCActGrowupBuyGroup()
            _pos = temGroupList.ReadData(_lpData, _pos)
            self.GroupList.append(temGroupList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x31
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.GroupCount = 0
        self.GroupList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.GroupCount):
            length += self.GroupList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.GroupCount)
        for i in range(self.GroupCount):
            data = CommFunc.WriteString(data, self.GroupList[i].GetLength(), self.GroupList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                GroupCount:%d,
                                GroupList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.GroupCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActGrowupBuyInfo=tagMCActGrowupBuyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGrowupBuyInfo.Head.Cmd,m_NAtagMCActGrowupBuyInfo.Head.SubCmd))] = m_NAtagMCActGrowupBuyInfo


#------------------------------------------------------
# AA 81 ¹Å±¦Ñø³É»î¶¯ÐÅÏ¢ #tagMCActGubaoInfo

class  tagMCActGubaoItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGubaoItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 81 ¹Å±¦Ñø³É»î¶¯ÐÅÏ¢ //tagMCActGubaoInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActGubaoAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActGubaoItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActGubaoItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActGubaoBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActGubaoItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCActGubaoAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActGubaoItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCActGubaoAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCActGubaoInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ShopType = 0    #(WORD ShopType)// ¿ª·ÅÉ̵êÀàÐÍ£¬¿ÉÄÜΪ0²»¿ª·Å
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCActGubaoBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x81
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCActGubaoBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x81
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.LimitLV = 0
        self.ShopType = 0
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 2
        length += 2
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteWORD(data, self.ShopType)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                LimitLV:%d,
                                ShopType:%d,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.LimitLV,
                                self.ShopType,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActGubaoInfo=tagMCActGubaoInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGubaoInfo.Head.Cmd,m_NAtagMCActGubaoInfo.Head.SubCmd))] = m_NAtagMCActGubaoInfo


#------------------------------------------------------
# AA 82 ¹Å±¦Ñø³É»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActGubaoPlayerInfo

class  tagMCActGubaoPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("Score", c_int),    # µ±Ç°»ý·Ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x82
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x82
        self.ActNum = 0
        self.Score = 0
        return

    def GetLength(self):
        return sizeof(tagMCActGubaoPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 82 ¹Å±¦Ñø³É»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActGubaoPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                Score:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.Score
                                )
        return DumpString


m_NAtagMCActGubaoPlayerInfo=tagMCActGubaoPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGubaoPlayerInfo.Cmd,m_NAtagMCActGubaoPlayerInfo.SubCmd))] = m_NAtagMCActGubaoPlayerInfo


#------------------------------------------------------
# AA 54 Æï³èÊ¢Ñç»î¶¯ÐÅÏ¢ #tagMCActHorsePetFeastInfo

class  tagMCActHorsePetFeastTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime
                                )
        return DumpString


class  tagMCActHorsePetFeastInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    TimeCount = 0    #(BYTE TimeCount)
    ActTimeList = list()    #(vector<tagMCActHorsePetFeastTime> ActTimeList)// »î¶¯Ê±¼ä H:M Áбí
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x54
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.TimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TimeCount):
            temActTimeList = tagMCActHorsePetFeastTime()
            _pos = temActTimeList.ReadData(_lpData, _pos)
            self.ActTimeList.append(temActTimeList)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x54
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.TimeCount = 0
        self.ActTimeList = list()
        self.LimitLV = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        for i in range(self.TimeCount):
            length += self.ActTimeList[i].GetLength()
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.TimeCount)
        for i in range(self.TimeCount):
            data = CommFunc.WriteString(data, self.ActTimeList[i].GetLength(), self.ActTimeList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.LimitLV)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                TimeCount:%d,
                                ActTimeList:%s,
                                LimitLV:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.TimeCount,
                                "...",
                                self.LimitLV
                                )
        return DumpString


m_NAtagMCActHorsePetFeastInfo=tagMCActHorsePetFeastInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetFeastInfo.Head.Cmd,m_NAtagMCActHorsePetFeastInfo.Head.SubCmd))] = m_NAtagMCActHorsePetFeastInfo


#------------------------------------------------------
# AA 84 Æï³èÑø³É»î¶¯ÐÅÏ¢ #tagMCActHorsePetTrainInfo

class  tagMCActHorsePetTrainItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActHorsePetTrainItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 84 Æï³èÑø³É»î¶¯ÐÅÏ¢ //tagMCActHorsePetTrainInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActHorsePetTrainAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActHorsePetTrainItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActHorsePetTrainItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActHorsePetTrainBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActHorsePetTrainItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCActHorsePetTrainAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActHorsePetTrainItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCActHorsePetTrainAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCActHorsePetTrainInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ShopType = 0    #(WORD ShopType)// ¿ª·ÅÉ̵êÀàÐÍ£¬¿ÉÄÜΪ0²»¿ª·Å
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCActHorsePetTrainBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x84
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCActHorsePetTrainBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x84
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.LimitLV = 0
        self.ShopType = 0
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 2
        length += 2
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteWORD(data, self.ShopType)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                LimitLV:%d,
                                ShopType:%d,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.LimitLV,
                                self.ShopType,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActHorsePetTrainInfo=tagMCActHorsePetTrainInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetTrainInfo.Head.Cmd,m_NAtagMCActHorsePetTrainInfo.Head.SubCmd))] = m_NAtagMCActHorsePetTrainInfo


#------------------------------------------------------
# AA 85 Æï³èÑø³É»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActHorsePetTrainPlayerInfo

class  tagMCActHorsePetTrainPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("Score", c_int),    # µ±Ç°»î¶¯»ý·Ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x85
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x85
        self.ActNum = 0
        self.Score = 0
        return

    def GetLength(self):
        return sizeof(tagMCActHorsePetTrainPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 85 Æï³èÑø³É»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActHorsePetTrainPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                Score:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.Score
                                )
        return DumpString


m_NAtagMCActHorsePetTrainPlayerInfo=tagMCActHorsePetTrainPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetTrainPlayerInfo.Cmd,m_NAtagMCActHorsePetTrainPlayerInfo.SubCmd))] = m_NAtagMCActHorsePetTrainPlayerInfo


#------------------------------------------------------
# AA 0C µÇ¼½±Àø»î¶¯ÐÅÏ¢ #tagMCActLoginAwardInfo

class  tagMCActLoginAwardAction(Structure):
    TemplateID = 0    #(DWORD TemplateID)// Ä£°åID
    ActionType = 0    #(WORD ActionType)// »î¶¯Àà±ð
    TotalTimes = 0    #(DWORD TotalTimes)// ¿ÉÍê³ÉµÄ×Ü´ÎÊý£¬0±íʾ²»ÏÞ´ÎÊý
    SingleTimes = 0    #(DWORD SingleTimes)// µ¥´ÎÁì½±ÐèÒªµÄ´ÎÊý
    Count = 0    #(WORD Count)// ÎïÆ·ÅäÖó¤¶È
    ItemInfo = ""    #(String ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TemplateID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ActionType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TotalTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SingleTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.Count)
        return _pos

    def Clear(self):
        self.TemplateID = 0
        self.ActionType = 0
        self.TotalTimes = 0
        self.SingleTimes = 0
        self.Count = 0
        self.ItemInfo = ""
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 2
        length += 4
        length += 4
        length += 2
        length += len(self.ItemInfo)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.TemplateID)
        data = CommFunc.WriteWORD(data, self.ActionType)
        data = CommFunc.WriteDWORD(data, self.TotalTimes)
        data = CommFunc.WriteDWORD(data, self.SingleTimes)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteString(data, self.Count, self.ItemInfo)
        return data

    def OutputString(self):
        DumpString = '''
                                TemplateID:%d,
                                ActionType:%d,
                                TotalTimes:%d,
                                SingleTimes:%d,
                                Count:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.TemplateID,
                                self.ActionType,
                                self.TotalTimes,
                                self.SingleTimes,
                                self.Count,
                                self.ItemInfo
                                )
        return DumpString


class  tagMCActLoginAwardDayInfo(Structure):
    ActCnt = 0    #(BYTE ActCnt)// ÊýÁ¿
    TemplateList = list()    #(vector<WORD> TemplateList)// Ä£°åÁбí
    WorldLV = 0    #(WORD WorldLV)// ÊÀ½çµÈ¼¶
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ActCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActCnt):
            value,_pos=CommFunc.ReadWORD(_lpData,_pos)
            self.TemplateList.append(value)
        self.WorldLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ActCnt = 0
        self.TemplateList = list()
        self.WorldLV = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2 * self.ActCnt
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ActCnt)
        for i in range(self.ActCnt):
            data = CommFunc.WriteWORD(data, self.TemplateList[i])
        data = CommFunc.WriteWORD(data, self.WorldLV)
        return data

    def OutputString(self):
        DumpString = '''
                                ActCnt:%d,
                                TemplateList:%s,
                                WorldLV:%d
                                '''\
                                %(
                                self.ActCnt,
                                "...",
                                self.WorldLV
                                )
        return DumpString


class  tagMCActLoginAwardInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    DayCnt = 0    #(BYTE DayCnt)// ÌìÊý
    DayInfoList = list()    #(vector<tagMCActLoginAwardDayInfo> DayInfoList)// ÿÌìÄ£°å
    TCount = 0    #(BYTE TCount)// Ä£°åÊý
    ActionInfo = list()    #(vector<tagMCActLoginAwardAction> ActionInfo)// »î¶¯Ä£°åÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0C
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.DayCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DayCnt):
            temDayInfoList = tagMCActLoginAwardDayInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        self.TCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TCount):
            temActionInfo = tagMCActLoginAwardAction()
            _pos = temActionInfo.ReadData(_lpData, _pos)
            self.ActionInfo.append(temActionInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0C
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.DayCnt = 0
        self.DayInfoList = list()
        self.TCount = 0
        self.ActionInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.DayCnt):
            length += self.DayInfoList[i].GetLength()
        length += 1
        for i in range(self.TCount):
            length += self.ActionInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.DayCnt)
        for i in range(self.DayCnt):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TCount)
        for i in range(self.TCount):
            data = CommFunc.WriteString(data, self.ActionInfo[i].GetLength(), self.ActionInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                DayCnt:%d,
                                DayInfoList:%s,
                                TCount:%d,
                                ActionInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.DayCnt,
                                "...",
                                self.TCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActLoginAwardInfo=tagMCActLoginAwardInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLoginAwardInfo.Head.Cmd,m_NAtagMCActLoginAwardInfo.Head.SubCmd))] = m_NAtagMCActLoginAwardInfo


#------------------------------------------------------
# AA 0D µÇ¼½±ÀøÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCActLoginAwardPlayerInfo

class  tagMCActLoginAwardTaskInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TemplateID", c_ushort),    # Ä£°åID
                  ("CurTimes", c_ushort),    #ÒÑÍê³É´ÎÊý
                  ("GotTimes", 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.TemplateID = 0
        self.CurTimes = 0
        self.GotTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCActLoginAwardTaskInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 0D µÇ¼½±ÀøÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCActLoginAwardPlayerInfo:
                                TemplateID:%d,
                                CurTimes:%d,
                                GotTimes:%d
                                '''\
                                %(
                                self.TemplateID,
                                self.CurTimes,
                                self.GotTimes
                                )
        return DumpString


class  tagMCActLoginAwardDayPlayerInfo(Structure):
    DayIndex = 0    #(DWORD DayIndex)//µÚXÌì
    ACount = 0    #(DWORD ACount)//ÈÎÎñÌõÄ¿Êý
    TaskList = list()    #(vector<tagMCActLoginAwardTaskInfo> TaskList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ACount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        for i in range(self.ACount):
            temTaskList = tagMCActLoginAwardTaskInfo()
            _pos = temTaskList.ReadData(_lpData, _pos)
            self.TaskList.append(temTaskList)
        return _pos

    def Clear(self):
        self.DayIndex = 0
        self.ACount = 0
        self.TaskList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        for i in range(self.ACount):
            length += self.TaskList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.DayIndex)
        data = CommFunc.WriteDWORD(data, self.ACount)
        for i in range(self.ACount):
            data = CommFunc.WriteString(data, self.TaskList[i].GetLength(), self.TaskList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayIndex:%d,
                                ACount:%d,
                                TaskList:%s
                                '''\
                                %(
                                self.DayIndex,
                                self.ACount,
                                "..."
                                )
        return DumpString


class  tagMCActLoginAwardPlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    DayInfoList = list()    #(vector<tagMCActLoginAwardDayPlayerInfo> DayInfoList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0D
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temDayInfoList = tagMCActLoginAwardDayPlayerInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0D
        self.Count = 0
        self.DayInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.DayInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                DayInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCActLoginAwardPlayerInfo=tagMCActLoginAwardPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLoginAwardPlayerInfo.Head.Cmd,m_NAtagMCActLoginAwardPlayerInfo.Head.SubCmd))] = m_NAtagMCActLoginAwardPlayerInfo


#------------------------------------------------------
# AA 69 µÇ¼»î¶¯ÐÅϢР#tagMCActLoginNew

class  tagMCActLoginNewItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActLoginNewItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 69 µÇ¼»î¶¯ÐÅϢР//tagMCActLoginNew:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActLoginNewDay(Structure):
    DayNum = 0    #(BYTE DayNum)//Ìì±àºÅ£¬´Ó1¿ªÊ¼£¬¹ýÆÚδǩµ½ÁìÈ¡µÄÌì¿ÉÏûºÄ»õ±Ò²¹Ç©ÁìÈ¡
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActLoginNewItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActLoginNewItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.DayNum = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.DayNum)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayNum:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.DayNum,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActLoginNew(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    RepSignMoneyType = 0    #(BYTE RepSignMoneyType)// ²¹Ç©ÏûºÄ»õ±ÒÀàÐÍ
    RepSignMoneyValue = 0    #(DWORD RepSignMoneyValue)// ²¹Ç©ÏûºÄ»õ±ÒÖµ
    DayCount = 0    #(BYTE DayCount)
    AwardDayList = list()    #(vector<tagMCActLoginNewDay> AwardDayList)// ½±ÀøÌìÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x69
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RepSignMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RepSignMoneyValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DayCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DayCount):
            temAwardDayList = tagMCActLoginNewDay()
            _pos = temAwardDayList.ReadData(_lpData, _pos)
            self.AwardDayList.append(temAwardDayList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x69
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.RepSignMoneyType = 0
        self.RepSignMoneyValue = 0
        self.DayCount = 0
        self.AwardDayList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        length += 4
        length += 1
        for i in range(self.DayCount):
            length += self.AwardDayList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.RepSignMoneyType)
        data = CommFunc.WriteDWORD(data, self.RepSignMoneyValue)
        data = CommFunc.WriteBYTE(data, self.DayCount)
        for i in range(self.DayCount):
            data = CommFunc.WriteString(data, self.AwardDayList[i].GetLength(), self.AwardDayList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                RepSignMoneyType:%d,
                                RepSignMoneyValue:%d,
                                DayCount:%d,
                                AwardDayList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.RepSignMoneyType,
                                self.RepSignMoneyValue,
                                self.DayCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActLoginNew=tagMCActLoginNew()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLoginNew.Head.Cmd,m_NAtagMCActLoginNew.Head.SubCmd))] = m_NAtagMCActLoginNew


#------------------------------------------------------
# AA 70 µÇ¼»î¶¯Íæ¼ÒÐÅϢР#tagMCActLoginPlayerInfoNew

class  tagMCActLoginPlayerInfoNew(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("LoginAward", c_int),    # ÊÇ·ñÒÑÁìÈ¡£¬°´ÌìË÷Òý0´ú±íµÚ1Ìì¼Ç¼µ±ÌìÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x70
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x70
        self.ActNum = 0
        self.LoginAward = 0
        return

    def GetLength(self):
        return sizeof(tagMCActLoginPlayerInfoNew)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 70 µÇ¼»î¶¯Íæ¼ÒÐÅϢР//tagMCActLoginPlayerInfoNew:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                LoginAward:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.LoginAward
                                )
        return DumpString


m_NAtagMCActLoginPlayerInfoNew=tagMCActLoginPlayerInfoNew()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLoginPlayerInfoNew.Cmd,m_NAtagMCActLoginPlayerInfoNew.SubCmd))] = m_NAtagMCActLoginPlayerInfoNew


#------------------------------------------------------
# AA 88 Âֻصî»î¶¯ÐÅÏ¢ #tagMCActLunhuidianInfo

class  tagMCActLunhuidianItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActLunhuidianItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 88 Âֻصî»î¶¯ÐÅÏ¢ //tagMCActLunhuidianInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActLunhuidianAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±Àø¼Ç¼Ë÷Òý 0~30
    NeedValue = 0    #(DWORD NeedValue)// ½±ÀøËùÐèÖµ
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActLunhuidianItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActLunhuidianItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedValue = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedValue)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedValue:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedValue,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActLunhuidianRound(Structure):
    RoundType = 0    #(BYTE RoundType)// ÂÖ»ØÀàÐÍ
    AwardType = 0    #(BYTE AwardType)// ½±ÀøÀàÐÍ 1-ÏûºÄ»õ±Ò£»2-Ñ°±¦´ÎÊý
    AwardTypeValue = 0    #(DWORD AwardTypeValue)// ½±ÀøÀàÐͶÔÓ¦Öµ£¬ÏûºÄ»õ±ÒʱΪ¶ÔÓ¦µÄ»õ±ÒÀàÐÍ£¬Ñ°±¦Ê±Îª¶ÔÓ¦µÄÑ°±¦ÀàÐÍ
    RoundMax = 0    #(BYTE RoundMax)// ×î´ó¿ÉÑ­»·ÂÖ´Î
    AwardCount = 0    #(BYTE AwardCount)
    AwardList = list()    #(vector<tagMCActLunhuidianAward> AwardList)// ÿÂÖ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.RoundType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardTypeValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RoundMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardList = tagMCActLunhuidianAward()
            _pos = temAwardList.ReadData(_lpData, _pos)
            self.AwardList.append(temAwardList)
        return _pos

    def Clear(self):
        self.RoundType = 0
        self.AwardType = 0
        self.AwardTypeValue = 0
        self.RoundMax = 0
        self.AwardCount = 0
        self.AwardList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 4
        length += 1
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.RoundType)
        data = CommFunc.WriteBYTE(data, self.AwardType)
        data = CommFunc.WriteDWORD(data, self.AwardTypeValue)
        data = CommFunc.WriteBYTE(data, self.RoundMax)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardList[i].GetLength(), self.AwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                RoundType:%d,
                                AwardType:%d,
                                AwardTypeValue:%d,
                                RoundMax:%d,
                                AwardCount:%d,
                                AwardList:%s
                                '''\
                                %(
                                self.RoundType,
                                self.AwardType,
                                self.AwardTypeValue,
                                self.RoundMax,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


class  tagMCActLunhuidianInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    RoundCount = 0    #(BYTE RoundCount)
    RoundList = list()    #(vector<tagMCActLunhuidianRound> RoundList)// ÂÖ»ØÁÐ±í£¬Ö§³Ö¶à¸ö²»Í¬ÀàÐÍÂÖ»Øͬʱ¿ªÆô
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x88
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RoundCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RoundCount):
            temRoundList = tagMCActLunhuidianRound()
            _pos = temRoundList.ReadData(_lpData, _pos)
            self.RoundList.append(temRoundList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x88
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.ResetType = 0
        self.LimitLV = 0
        self.RoundCount = 0
        self.RoundList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.RoundCount):
            length += self.RoundList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.RoundCount)
        for i in range(self.RoundCount):
            data = CommFunc.WriteString(data, self.RoundList[i].GetLength(), self.RoundList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                ResetType:%d,
                                LimitLV:%d,
                                RoundCount:%d,
                                RoundList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.ResetType,
                                self.LimitLV,
                                self.RoundCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActLunhuidianInfo=tagMCActLunhuidianInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLunhuidianInfo.Head.Cmd,m_NAtagMCActLunhuidianInfo.Head.SubCmd))] = m_NAtagMCActLunhuidianInfo


#------------------------------------------------------
# AA 89 Âֻصî»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActLunhuidianPlayerInfo

class  tagMCActLunhuidianPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("RoundType", c_ubyte),    # ÂÖ»ØÀàÐÍ
                  ("CurRound", c_ubyte),    # µ±Ç°ÂÖ´Î
                  ("CurValue", c_int),    # ÀÛ¼ÆÖµ
                  ("AwardRecord", c_int),    # µ±Ç°Âִν±ÀøÁì½±¼Ç¼£¬°´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡£¬ËùÓн±ÀøÒÑÁìÈ¡ºó×Ô¶¯½øÈëÏÂÒ»ÂÖ£¬ÇÒÖØÖøý±Àø״̬
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x89
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x89
        self.ActNum = 0
        self.RoundType = 0
        self.CurRound = 0
        self.CurValue = 0
        self.AwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCActLunhuidianPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 89 Âֻصî»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActLunhuidianPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                RoundType:%d,
                                CurRound:%d,
                                CurValue:%d,
                                AwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.RoundType,
                                self.CurRound,
                                self.CurValue,
                                self.AwardRecord
                                )
        return DumpString


m_NAtagMCActLunhuidianPlayerInfo=tagMCActLunhuidianPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLunhuidianPlayerInfo.Cmd,m_NAtagMCActLunhuidianPlayerInfo.SubCmd))] = m_NAtagMCActLunhuidianPlayerInfo


#------------------------------------------------------
# AA 48 ¶àÈÕÁ¬³ä»î¶¯ÐÅÏ¢ #tagMCActManyDayRechargeInfo

class  tagMCActManyDayRechargeItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActManyDayRechargeItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 48 ¶àÈÕÁ¬³ä»î¶¯ÐÅÏ¢ //tagMCActManyDayRechargeInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActManyDayRechargeAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý 0~31
    NeedRecharge = 0    #(DWORD NeedRecharge)// µ¥ÌìËùÐè³äÖµ¶î¶È
    NeedDays = 0    #(BYTE NeedDays)// ËùÐè³äÖµÌìÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)
    AwardItemList = list()    #(vector<tagMCActManyDayRechargeItem> AwardItemList)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedRecharge,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NeedDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCActManyDayRechargeItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedRecharge = 0
        self.NeedDays = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 1
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedRecharge)
        data = CommFunc.WriteBYTE(data, self.NeedDays)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedRecharge:%d,
                                NeedDays:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedRecharge,
                                self.NeedDays,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActManyDayRechargeInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AwardCount = 0    #(BYTE AwardCount)
    AwardList = list()    #(vector<tagMCActManyDayRechargeAward> AwardList)// ½±ÀøÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x48
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardList = tagMCActManyDayRechargeAward()
            _pos = temAwardList.ReadData(_lpData, _pos)
            self.AwardList.append(temAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x48
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.AwardCount = 0
        self.AwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardList[i].GetLength(), self.AwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                AwardCount:%d,
                                AwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActManyDayRechargeInfo=tagMCActManyDayRechargeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActManyDayRechargeInfo.Head.Cmd,m_NAtagMCActManyDayRechargeInfo.Head.SubCmd))] = m_NAtagMCActManyDayRechargeInfo


#------------------------------------------------------
# AA 49 ¶àÈÕÁ¬³ä»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActManyDayRechargePlayerInfo

class  tagMCActManyDayRechargePlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    Days = 0    #(BYTE Days)
    DayRechargeValues = list()    #(vector<DWORD> DayRechargeValues)//»î¶¯Ã¿Ìì³äÖµÁбí
    RecordCount = 0    #(BYTE RecordCount)
    AwardRecord = list()    #(vector<DWORD> AwardRecord)//½±ÀøÁì½±¼Ç¼£¬°´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x49
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Days,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Days):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.DayRechargeValues.append(value)
        self.RecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RecordCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.AwardRecord.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x49
        self.ActNum = 0
        self.Days = 0
        self.DayRechargeValues = list()
        self.RecordCount = 0
        self.AwardRecord = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4 * self.Days
        length += 1
        length += 4 * self.RecordCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.Days)
        for i in range(self.Days):
            data = CommFunc.WriteDWORD(data, self.DayRechargeValues[i])
        data = CommFunc.WriteBYTE(data, self.RecordCount)
        for i in range(self.RecordCount):
            data = CommFunc.WriteDWORD(data, self.AwardRecord[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                Days:%d,
                                DayRechargeValues:%s,
                                RecordCount:%d,
                                AwardRecord:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.Days,
                                "...",
                                self.RecordCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActManyDayRechargePlayerInfo=tagMCActManyDayRechargePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActManyDayRechargePlayerInfo.Head.Cmd,m_NAtagMCActManyDayRechargePlayerInfo.Head.SubCmd))] = m_NAtagMCActManyDayRechargePlayerInfo


#------------------------------------------------------
# AA 62 ³äÖµµÖ¿Û»î¶¯ÐÅÏ¢ #tagMCActRecharegeCouponInfo

class  tagMCActRecharegeCouponItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ("IsMainItem", c_ubyte),    #ÊÇ·ñ±êµÄÎï
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        self.IsMainItem = 0
        return

    def GetLength(self):
        return sizeof(tagMCActRecharegeCouponItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 62 ³äÖµµÖ¿Û»î¶¯ÐÅÏ¢ //tagMCActRecharegeCouponInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d,
                                IsMainItem:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind,
                                self.IsMainItem
                                )
        return DumpString


class  tagMCActRecharegeCouponGiftbag(Structure):
    GiftID = 0    #(DWORD GiftID)//É̳DZíµÄÎïÆ·ID
    BuyCountLimit = 0    #(BYTE BuyCountLimit)//ÏÞ¹ºÊý
    MoneyType = 0    #(BYTE MoneyType)//ÏûºÄ»õ±ÒÀàÐÍ
    MoneyNumber = 0    #(DWORD MoneyNumber)//ÏûºÄ»õ±ÒÊýÁ¿
    MoneyOriginal = 0    #(DWORD MoneyOriginal)//Ô­¼Û
    GiftItemCount = 0    #(BYTE GiftItemCount)// Àñ°üÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCActRecharegeCouponItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BuyCountLimit,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyNumber,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MoneyOriginal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftItemCount):
            temItemInfo = tagMCActRecharegeCouponItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        return _pos

    def Clear(self):
        self.GiftID = 0
        self.BuyCountLimit = 0
        self.MoneyType = 0
        self.MoneyNumber = 0
        self.MoneyOriginal = 0
        self.GiftItemCount = 0
        self.ItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.GiftItemCount):
            length += self.ItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.GiftID)
        data = CommFunc.WriteBYTE(data, self.BuyCountLimit)
        data = CommFunc.WriteBYTE(data, self.MoneyType)
        data = CommFunc.WriteDWORD(data, self.MoneyNumber)
        data = CommFunc.WriteDWORD(data, self.MoneyOriginal)
        data = CommFunc.WriteBYTE(data, self.GiftItemCount)
        for i in range(self.GiftItemCount):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GiftID:%d,
                                BuyCountLimit:%d,
                                MoneyType:%d,
                                MoneyNumber:%d,
                                MoneyOriginal:%d,
                                GiftItemCount:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.GiftID,
                                self.BuyCountLimit,
                                self.MoneyType,
                                self.MoneyNumber,
                                self.MoneyOriginal,
                                self.GiftItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActRecharegeCouponInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    CouponMoneyType = 0    #(BYTE CouponMoneyType)//µÖ¿Ûȯ¶ÔÓ¦»õ±ÒÀàÐÍ
    GiftbagCount = 0    #(BYTE GiftbagCount)// ¿É¹ºÂòÀñ°ü¸öÊý
    GiftbagList = list()    #(vector<tagMCActRecharegeCouponGiftbag> GiftbagList)// ¿É¹ºÂòÀñ°ü˳ÐòÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x62
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.CouponMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagList = tagMCActRecharegeCouponGiftbag()
            _pos = temGiftbagList.ReadData(_lpData, _pos)
            self.GiftbagList.append(temGiftbagList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x62
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.CouponMoneyType = 0
        self.GiftbagCount = 0
        self.GiftbagList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.CouponMoneyType)
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagList[i].GetLength(), self.GiftbagList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                CouponMoneyType:%d,
                                GiftbagCount:%d,
                                GiftbagList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.CouponMoneyType,
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActRecharegeCouponInfo=tagMCActRecharegeCouponInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActRecharegeCouponInfo.Head.Cmd,m_NAtagMCActRecharegeCouponInfo.Head.SubCmd))] = m_NAtagMCActRecharegeCouponInfo


#------------------------------------------------------
# AA 63 ³äÖµµÖ¿Û»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActRecharegeCouponPlayerInfo

class  tagMCActRecharegeCouponPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("CouponMoney", c_int),    # µ±Ç°¿ÉÓõֿ۵ã
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x63
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x63
        self.ActNum = 0
        self.CouponMoney = 0
        return

    def GetLength(self):
        return sizeof(tagMCActRecharegeCouponPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 63 ³äÖµµÖ¿Û»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActRecharegeCouponPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                CouponMoney:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.CouponMoney
                                )
        return DumpString


m_NAtagMCActRecharegeCouponPlayerInfo=tagMCActRecharegeCouponPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActRecharegeCouponPlayerInfo.Cmd,m_NAtagMCActRecharegeCouponPlayerInfo.SubCmd))] = m_NAtagMCActRecharegeCouponPlayerInfo


#------------------------------------------------------
# AA 27 ³äÖµ·µÀû»î¶¯ÐÅÏ¢ #tagMCActRechargePrizeInfo

class  tagMCActRechargePrize(Structure):
    _pack_ = 1
    _fields_ = [
                  ("CTGID", c_ushort),    # ¶ÔÓ¦³äÖµ±í³äÖµID
                  ("GoldPrize", c_int),    #·µÀûÏÉÓñÊý
                  ("PrizeCountLimit", c_ubyte),    #ÏÞÖÆ×î´ó·µÀû´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.CTGID = 0
        self.GoldPrize = 0
        self.PrizeCountLimit = 0
        return

    def GetLength(self):
        return sizeof(tagMCActRechargePrize)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 27 ³äÖµ·µÀû»î¶¯ÐÅÏ¢ //tagMCActRechargePrizeInfo:
                                CTGID:%d,
                                GoldPrize:%d,
                                PrizeCountLimit:%d
                                '''\
                                %(
                                self.CTGID,
                                self.GoldPrize,
                                self.PrizeCountLimit
                                )
        return DumpString


class  tagMCActRechargePrizeDay(Structure):
    Prizes = 0    #(BYTE Prizes)// ·µÀûµµÊý
    PrizeInfo = list()    #(vector<tagMCActRechargePrize> PrizeInfo)// ·µÀûµµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Prizes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Prizes):
            temPrizeInfo = tagMCActRechargePrize()
            _pos = temPrizeInfo.ReadData(_lpData, _pos)
            self.PrizeInfo.append(temPrizeInfo)
        return _pos

    def Clear(self):
        self.Prizes = 0
        self.PrizeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.Prizes):
            length += self.PrizeInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Prizes)
        for i in range(self.Prizes):
            data = CommFunc.WriteString(data, self.PrizeInfo[i].GetLength(), self.PrizeInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Prizes:%d,
                                PrizeInfo:%s
                                '''\
                                %(
                                self.Prizes,
                                "..."
                                )
        return DumpString


class  tagMCActRechargePrizeInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    PrizeDays = 0    #(BYTE PrizeDays)
    PrizeDayInfo = list()    #(vector<tagMCActRechargePrizeDay> PrizeDayInfo)//ÿÌì¶ÔÓ¦ÐÅÏ¢; Èç¹ûÖ»ÓÐÒ»Ì죬µ«ÊǻÓжàÌ죬Ôò´ú±íÿÌì½±Àø¶¼Ò»Ñù
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x27
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PrizeDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PrizeDays):
            temPrizeDayInfo = tagMCActRechargePrizeDay()
            _pos = temPrizeDayInfo.ReadData(_lpData, _pos)
            self.PrizeDayInfo.append(temPrizeDayInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x27
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.IsDayReset = 0
        self.PrizeDays = 0
        self.PrizeDayInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        for i in range(self.PrizeDays):
            length += self.PrizeDayInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.PrizeDays)
        for i in range(self.PrizeDays):
            data = CommFunc.WriteString(data, self.PrizeDayInfo[i].GetLength(), self.PrizeDayInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                IsDayReset:%d,
                                PrizeDays:%d,
                                PrizeDayInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.IsDayReset,
                                self.PrizeDays,
                                "..."
                                )
        return DumpString


m_NAtagMCActRechargePrizeInfo=tagMCActRechargePrizeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActRechargePrizeInfo.Head.Cmd,m_NAtagMCActRechargePrizeInfo.Head.SubCmd))] = m_NAtagMCActRechargePrizeInfo


#------------------------------------------------------
# AA 29 ÀۼƳäÖµ·µÀûÏÉÓñ»î¶¯ÐÅÏ¢ #tagMCActRechargeRebateGoldInfo

class  tagMCActRechargeRebate(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RMBMin", c_int),    # ³äÖµRMB×îСֵ
                  ("RMBMax", c_int),    # ³äÖµRMB×î´óÖµ£¬0´ú±íÎÞÉÏÏÞ
                  ("RebateRate", 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.RMBMin = 0
        self.RMBMax = 0
        self.RebateRate = 0
        return

    def GetLength(self):
        return sizeof(tagMCActRechargeRebate)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 29 ÀۼƳäÖµ·µÀûÏÉÓñ»î¶¯ÐÅÏ¢ //tagMCActRechargeRebateGoldInfo:
                                RMBMin:%d,
                                RMBMax:%d,
                                RebateRate:%d
                                '''\
                                %(
                                self.RMBMin,
                                self.RMBMax,
                                self.RebateRate
                                )
        return DumpString


class  tagMCActRechargeRebateDay(Structure):
    Rebates = 0    #(BYTE Rebates)// ·µÀûµµÊý
    RebateInfo = list()    #(vector<tagMCActRechargeRebate> RebateInfo)// ·µÀûµµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rebates,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Rebates):
            temRebateInfo = tagMCActRechargeRebate()
            _pos = temRebateInfo.ReadData(_lpData, _pos)
            self.RebateInfo.append(temRebateInfo)
        return _pos

    def Clear(self):
        self.Rebates = 0
        self.RebateInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.Rebates):
            length += self.RebateInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Rebates)
        for i in range(self.Rebates):
            data = CommFunc.WriteString(data, self.RebateInfo[i].GetLength(), self.RebateInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rebates:%d,
                                RebateInfo:%s
                                '''\
                                %(
                                self.Rebates,
                                "..."
                                )
        return DumpString


class  tagMCActRechargeRebateGoldInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    RebateDays = 0    #(BYTE RebateDays)
    RebateDayInfo = list()    #(vector<tagMCActRechargeRebateDay> RebateDayInfo)//ÿÌì¶ÔÓ¦ÐÅÏ¢; Èç¹ûÖ»ÓÐÒ»Ì죬µ«ÊǻÓжàÌ죬Ôò´ú±íÿÌì½±Àø¶¼Ò»Ñù
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x29
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RebateDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RebateDays):
            temRebateDayInfo = tagMCActRechargeRebateDay()
            _pos = temRebateDayInfo.ReadData(_lpData, _pos)
            self.RebateDayInfo.append(temRebateDayInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x29
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.IsDayReset = 0
        self.RebateDays = 0
        self.RebateDayInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        for i in range(self.RebateDays):
            length += self.RebateDayInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.RebateDays)
        for i in range(self.RebateDays):
            data = CommFunc.WriteString(data, self.RebateDayInfo[i].GetLength(), self.RebateDayInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                IsDayReset:%d,
                                RebateDays:%d,
                                RebateDayInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.IsDayReset,
                                self.RebateDays,
                                "..."
                                )
        return DumpString


m_NAtagMCActRechargeRebateGoldInfo=tagMCActRechargeRebateGoldInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActRechargeRebateGoldInfo.Head.Cmd,m_NAtagMCActRechargeRebateGoldInfo.Head.SubCmd))] = m_NAtagMCActRechargeRebateGoldInfo


#------------------------------------------------------
# AA 50 µ¥±ÊÀÛ³ä»î¶¯ÐÅÏ¢ #tagMCActSingleRechargeInfo

class  tagMCActSingleRechargeAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActSingleRechargeAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 50 µ¥±ÊÀÛ³ä»î¶¯ÐÅÏ¢ //tagMCActSingleRechargeInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActSingleRechargeAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý
    AwardCountMax = 0    #(WORD AwardCountMax)// ×î´óÁì½±´ÎÊý
    SingleRechargeValue = 0    #(DWORD SingleRechargeValue)// µ¥±ÊËùÐè³äÖµ¶î¶È
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItem = list()    #(vector<tagMCActSingleRechargeAwardItem> AwardItem)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardCountMax,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.SingleRechargeValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItem = tagMCActSingleRechargeAwardItem()
            _pos = temAwardItem.ReadData(_lpData, _pos)
            self.AwardItem.append(temAwardItem)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.AwardCountMax = 0
        self.SingleRechargeValue = 0
        self.AwardItemCount = 0
        self.AwardItem = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItem[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteWORD(data, self.AwardCountMax)
        data = CommFunc.WriteDWORD(data, self.SingleRechargeValue)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItem[i].GetLength(), self.AwardItem[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                AwardCountMax:%d,
                                SingleRechargeValue:%d,
                                AwardItemCount:%d,
                                AwardItem:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.AwardCountMax,
                                self.SingleRechargeValue,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCActSingleRechargeInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AwardRuleType = 0    #(BYTE AwardRuleType)// Áì½±¹æÔòÀàÐÍ 0-ÏòϼæÈÝ£»1-Æ¥Åä×î¸ßµµ£»2-¾«È·Æ¥Åä¶ÔÓ¦µµ´Î
    AwardCount = 0    #(BYTE AwardCount)// ½±ÀøµµÊý
    AwardInfo = list()    #(vector<tagMCActSingleRechargeAward> AwardInfo)// ½±ÀøµµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x50
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardRuleType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardInfo = tagMCActSingleRechargeAward()
            _pos = temAwardInfo.ReadData(_lpData, _pos)
            self.AwardInfo.append(temAwardInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x50
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.AwardRuleType = 0
        self.AwardCount = 0
        self.AwardInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.AwardRuleType)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardInfo[i].GetLength(), self.AwardInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                AwardRuleType:%d,
                                AwardCount:%d,
                                AwardInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.AwardRuleType,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActSingleRechargeInfo=tagMCActSingleRechargeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActSingleRechargeInfo.Head.Cmd,m_NAtagMCActSingleRechargeInfo.Head.SubCmd))] = m_NAtagMCActSingleRechargeInfo


#------------------------------------------------------
# AA 51 µ¥±ÊÀÛ³ä»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActSingleRechargePlayerInfo

class  tagMCActSingleRechargePlayerAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("AwardIndex", c_ubyte),    # ½±ÀøË÷Òý
                  ("CanGetCount", c_ushort),    # ¿ÉÁì½±´ÎÊý
                  ("GetCount", 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.AwardIndex = 0
        self.CanGetCount = 0
        self.GetCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCActSingleRechargePlayerAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 51 µ¥±ÊÀÛ³ä»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActSingleRechargePlayerInfo:
                                AwardIndex:%d,
                                CanGetCount:%d,
                                GetCount:%d
                                '''\
                                %(
                                self.AwardIndex,
                                self.CanGetCount,
                                self.GetCount
                                )
        return DumpString


class  tagMCActSingleRechargePlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ´Ó1¿ªÊ¼£¬Ä¿Ç°Ö§³ÖÁ½¸öÀÛ³ä»î¶¯Í¬Ê±´æÔÚÇÒÏ໥¶ÀÁ¢ 1»ò2
    RecordCount = 0    #(BYTE RecordCount)
    AwardRecordList = list()    #(vector<tagMCActSingleRechargePlayerAward> AwardRecordList)// Áì½±´ÎÊý¼Ç¼Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x51
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.RecordCount):
            temAwardRecordList = tagMCActSingleRechargePlayerAward()
            _pos = temAwardRecordList.ReadData(_lpData, _pos)
            self.AwardRecordList.append(temAwardRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x51
        self.ActNum = 0
        self.RecordCount = 0
        self.AwardRecordList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.RecordCount):
            length += self.AwardRecordList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.RecordCount)
        for i in range(self.RecordCount):
            data = CommFunc.WriteString(data, self.AwardRecordList[i].GetLength(), self.AwardRecordList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                RecordCount:%d,
                                AwardRecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.RecordCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActSingleRechargePlayerInfo=tagMCActSingleRechargePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActSingleRechargePlayerInfo.Head.Cmd,m_NAtagMCActSingleRechargePlayerInfo.Head.SubCmd))] = m_NAtagMCActSingleRechargePlayerInfo


#------------------------------------------------------
# AA 71 ÈÎÎñ»î¶¯ÐÅÏ¢ #tagMCActTaskInfo

class  tagMCActTaskItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActTaskItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 71 ÈÎÎñ»î¶¯ÐÅÏ¢ //tagMCActTaskInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActTask(Structure):
    TaskID = 0    #(DWORD TaskID)// ÈÎÎñID£¬1~n
    TaskType = 0    #(BYTE TaskType)// ÈÎÎñÀàÐÍ
    NeedValue = 0    #(DWORD NeedValue)// Íê³ÉÈÎÎñËùÐèÖµ
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActTaskItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TaskID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TaskType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActTaskItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.TaskID = 0
        self.TaskType = 0
        self.NeedValue = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.TaskID)
        data = CommFunc.WriteBYTE(data, self.TaskType)
        data = CommFunc.WriteDWORD(data, self.NeedValue)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TaskID:%d,
                                TaskType:%d,
                                NeedValue:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.TaskID,
                                self.TaskType,
                                self.NeedValue,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActTaskInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    TaskCount = 0    #(BYTE TaskCount)
    TaskList = list()    #(vector<tagMCActTask> TaskList)// ÈÎÎñÁбí
    RoundMax = 0    #(BYTE RoundMax)// ×î´ó¿ÉÑ­»·ÂִΣ¬µ±Ð¡ÓÚµÈÓÚ1ʱ´ú±í²»Ñ­»·
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x71
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TaskCount):
            temTaskList = tagMCActTask()
            _pos = temTaskList.ReadData(_lpData, _pos)
            self.TaskList.append(temTaskList)
        self.RoundMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x71
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.TaskCount = 0
        self.TaskList = list()
        self.RoundMax = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.TaskCount):
            length += self.TaskList[i].GetLength()
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.TaskCount)
        for i in range(self.TaskCount):
            data = CommFunc.WriteString(data, self.TaskList[i].GetLength(), self.TaskList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.RoundMax)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                TaskCount:%d,
                                TaskList:%s,
                                RoundMax:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.TaskCount,
                                "...",
                                self.RoundMax
                                )
        return DumpString


m_NAtagMCActTaskInfo=tagMCActTaskInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTaskInfo.Head.Cmd,m_NAtagMCActTaskInfo.Head.SubCmd))] = m_NAtagMCActTaskInfo


#------------------------------------------------------
# AA 73 ÈÎÎñ»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActTaskPlayerInfo

class  tagMCActTaskPlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    AwardCount = 0    #(BYTE AwardCount)
    AwardRecordList = list()    #(vector<DWORD> AwardRecordList)// ÈÎÎñIDÁì½±¼Ç¼ֵÁÐ±í£¬¸ù¾ÝÈÎÎñIDλÅжÏÊÇ·ñÒÑÁìÈ¡£¬Ò»¸ö¼Ç¼ֵ´æ31λ [¼Ç¼ֵ0, ¼Ç¼ֵ1, ...]
    RoundNum = 0    #(BYTE RoundNum)// µ±Ç°ÂִΣ¬´Ó1¿ªÊ¼
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x73
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.AwardRecordList.append(value)
        self.RoundNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x73
        self.ActNum = 0
        self.AwardCount = 0
        self.AwardRecordList = list()
        self.RoundNum = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 4 * self.AwardCount
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteDWORD(data, self.AwardRecordList[i])
        data = CommFunc.WriteBYTE(data, self.RoundNum)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                AwardCount:%d,
                                AwardRecordList:%s,
                                RoundNum:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.AwardCount,
                                "...",
                                self.RoundNum
                                )
        return DumpString


m_NAtagMCActTaskPlayerInfo=tagMCActTaskPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTaskPlayerInfo.Head.Cmd,m_NAtagMCActTaskPlayerInfo.Head.SubCmd))] = m_NAtagMCActTaskPlayerInfo


#------------------------------------------------------
# AA 72 ÈÎÎñ»î¶¯Íæ¼ÒÈÎÎñÖµ #tagMCActTaskPlayerValueInfo

class  tagMCActTaskPlayerValue(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TaskType", c_ubyte),    # ÈÎÎñÀàÐÍ
                  ("TaskValue", c_int),    # µ±Ç°ÈÎÎñÖµ£¬ËùÓÐÏàͬÈÎÎñÀàÐ͹²Ïí¸Ã½ø¶ÈÖµ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.TaskType = 0
        self.TaskValue = 0
        return

    def GetLength(self):
        return sizeof(tagMCActTaskPlayerValue)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 72 ÈÎÎñ»î¶¯Íæ¼ÒÈÎÎñÖµ //tagMCActTaskPlayerValueInfo:
                                TaskType:%d,
                                TaskValue:%d
                                '''\
                                %(
                                self.TaskType,
                                self.TaskValue
                                )
        return DumpString


class  tagMCActTaskPlayerValueInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    TaskCount = 0    #(BYTE TaskCount)
    TaskValueList = list()    #(vector<tagMCActTaskPlayerValue> TaskValueList)// ÓÐͬ²½µÄÈÎÎñÀàÐÍÖ±½Ó¸²¸Ç¼´¿É
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x72
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TaskCount):
            temTaskValueList = tagMCActTaskPlayerValue()
            _pos = temTaskValueList.ReadData(_lpData, _pos)
            self.TaskValueList.append(temTaskValueList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x72
        self.ActNum = 0
        self.TaskCount = 0
        self.TaskValueList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.TaskCount):
            length += self.TaskValueList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.TaskCount)
        for i in range(self.TaskCount):
            data = CommFunc.WriteString(data, self.TaskValueList[i].GetLength(), self.TaskValueList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                TaskCount:%d,
                                TaskValueList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.TaskCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActTaskPlayerValueInfo=tagMCActTaskPlayerValueInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTaskPlayerValueInfo.Head.Cmd,m_NAtagMCActTaskPlayerValueInfo.Head.SubCmd))] = m_NAtagMCActTaskPlayerValueInfo


#------------------------------------------------------
# AA 1D ÀۼƳäÖµ»î¶¯ÐÅÏ¢ #tagMCActTotalRechargeInfo

class  tagMCTotalRechargeAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCTotalRechargeAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1D ÀۼƳäÖµ»î¶¯ÐÅÏ¢ //tagMCActTotalRechargeInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCTotalRechargeAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý 0~31
    NeedGold = 0    #(DWORD NeedGold)// ËùÐèÏÉÓñÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItem = list()    #(vector<tagMCTotalRechargeAwardItem> AwardItem)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedGold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItem = tagMCTotalRechargeAwardItem()
            _pos = temAwardItem.ReadData(_lpData, _pos)
            self.AwardItem.append(temAwardItem)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedGold = 0
        self.AwardItemCount = 0
        self.AwardItem = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItem[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedGold)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItem[i].GetLength(), self.AwardItem[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedGold:%d,
                                AwardItemCount:%d,
                                AwardItem:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedGold,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCTotalRechargeAwardDay(Structure):
    AwardCount = 0    #(BYTE AwardCount)// ½±ÀøµµÊý
    AwardInfo = list()    #(vector<tagMCTotalRechargeAward> AwardInfo)// ½±ÀøµµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardInfo = tagMCTotalRechargeAward()
            _pos = temAwardInfo.ReadData(_lpData, _pos)
            self.AwardInfo.append(temAwardInfo)
        return _pos

    def Clear(self):
        self.AwardCount = 0
        self.AwardInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardInfo[i].GetLength(), self.AwardInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardCount:%d,
                                AwardInfo:%s
                                '''\
                                %(
                                self.AwardCount,
                                "..."
                                )
        return DumpString


class  tagMCActTotalRechargeInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ´Ó1¿ªÊ¼£¬Ä¿Ç°Ö§³ÖÁ½¸öÀÛ³ä»î¶¯Í¬Ê±´æÔÚÇÒÏ໥¶ÀÁ¢ 1»ò2
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AwardDays = 0    #(BYTE AwardDays)
    AwardDayInfo = list()    #(vector<tagMCTotalRechargeAwardDay> AwardDayInfo)//ÿÌì¶ÔÓ¦ÐÅÏ¢; Èç¹ûÖ»ÓÐÒ»Ì죬µ«ÊǻÓжàÌ죬Ôò´ú±íÿÌì½±Àø¶¼Ò»Ñù
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1D
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardDays):
            temAwardDayInfo = tagMCTotalRechargeAwardDay()
            _pos = temAwardDayInfo.ReadData(_lpData, _pos)
            self.AwardDayInfo.append(temAwardDayInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1D
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.AwardDays = 0
        self.AwardDayInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.AwardDays):
            length += self.AwardDayInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.AwardDays)
        for i in range(self.AwardDays):
            data = CommFunc.WriteString(data, self.AwardDayInfo[i].GetLength(), self.AwardDayInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                AwardDays:%d,
                                AwardDayInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.AwardDays,
                                "..."
                                )
        return DumpString


m_NAtagMCActTotalRechargeInfo=tagMCActTotalRechargeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTotalRechargeInfo.Head.Cmd,m_NAtagMCActTotalRechargeInfo.Head.SubCmd))] = m_NAtagMCActTotalRechargeInfo


#------------------------------------------------------
# AA 52 תÅ̻ÐÅÏ¢ #tagMCActTurntableInfo

class  tagMCActTurntableItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemNum", c_ubyte),    #ÎïÆ·±àºÅ 1~n£»×¢ÒâתÅÌÒÑÈ·¶¨ÎïÆ·±àºÅ Óë ¼«Æ·ÖÕ¼«ÎïÆ·´ýÑ¡Ôñ¿â±àºÅ¿ÉÄÜÏàͬ£¬µ«²¢²»´ú±íͬһÎïÆ·
                  ("ItemLibType", c_ubyte),    #ÎïÆ·¿âÀàÐÍ£»1-³£¹æ£¬2-¼«Æ·£¬3-ÖÕ¼«
                  ("ItemID", c_int),    
                  ("ItemCount", 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.ItemNum = 0
        self.ItemLibType = 0
        self.ItemID = 0
        self.ItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCActTurntableItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 52 תÅ̻ÐÅÏ¢ //tagMCActTurntableInfo:
                                ItemNum:%d,
                                ItemLibType:%d,
                                ItemID:%d,
                                ItemCount:%d
                                '''\
                                %(
                                self.ItemNum,
                                self.ItemLibType,
                                self.ItemID,
                                self.ItemCount
                                )
        return DumpString


class  tagMCActTurntableInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    CTGPrizeCount = 0    #(BYTE CTGPrizeCount)
    CTGPrizeList = list()    #(vector<DWORD> CTGPrizeList)// ÀۼƳäÖµ¶î¶È½±Àø´ÎÊýÁбí [½±ÀøµÚ1´ÎËùÐèÀۼƳäÖµ¶î¶È, µÚ2´Î, ...]
    UseMoneyType = 0    #(BYTE UseMoneyType)// ÀÛ¼ÆÏû·Ñ»õ±ÒÀàÐÍ
    UseMoneyPrizeCount = 0    #(BYTE UseMoneyPrizeCount)
    UseMoneyPrizeList = list()    #(vector<DWORD> UseMoneyPrizeList)// ÀÛ¼ÆÏû·Ñ»õ±Ò½±Àø´ÎÊýÁбí [½±ÀøµÚ1´ÎËùÐèÀÛ¼ÆÏû·Ñ»õ±Ò, µÚ2´Î, ...]
    TurnItemCount = 0    #(BYTE TurnItemCount)
    TurnItemList = list()    #(vector<tagMCActTurntableItem> TurnItemList)// תÅÌÒÑÈ·¶¨µÄÎïÆ·ÁÐ±í£¬°üº¬³£¹æÎïÆ·+¼«Æ·ÎïÆ·+ÖÕ¼«ÎïÆ·£¬»î¶¯¿ªÊ¼Ê±£¬ºó¶ËÖ±½ÓËæ»úÉú³É³£¹æÎïÆ·£¬ÒÑÈ·¶¨µÄÎïÆ·²»°üº¬¼«Æ·¡¢ÖÕ¼«ÎïƷʱÐèÒªÏÈÑ¡Ôñ²ÅÄÜʹÓÃתÅÌ£»
    GoodItemCount = 0    #(BYTE GoodItemCount)
    GoodItemList = list()    #(vector<tagMCActTurntableItem> GoodItemList)// ¼«Æ·ÎïÆ·´ýÑ¡Ôñ¿â£¬ÓÉÍæ¼Ò´Ó¿âÖÐÑ¡Ôñ·ÅÈëתÅ̵ÄÎïÆ·£»×¢Òâ´Ë¿âÖеÄÎïÆ·±àºÅ½ö±íʾÔڸÿâÖеıàºÅ£¬¿ÉÄÜÓëתÅÌÒÑÈ·¶¨µÄÎïÆ·±àºÅÖظ´£¬µ«²¢²»´ú±íͬһÎïÆ·£»
    GoodItemCanChooseCount = 0    #(BYTE GoodItemCanChooseCount)// ¼«Æ·ÎïÆ·¿ÉÑ¡Ôñ¸öÊý
    SuperItemCount = 0    #(BYTE SuperItemCount)
    SuperItemList = list()    #(vector<tagMCActTurntableItem> SuperItemList)// ÖÕ¼«ÎïÆ·´ýÑ¡Ôñ¿â£¬ÓÉÍæ¼Ò´Ó¿âÖÐÑ¡Ôñ·ÅÈëתÅ̵ÄÎïÆ·£»×¢Òâ´Ë¿âÖеÄÎïÆ·±àºÅ½ö±íʾÔڸÿâÖеıàºÅ£¬¿ÉÄÜÓëתÅÌÒÑÈ·¶¨µÄÎïÆ·±àºÅÖظ´£¬µ«²¢²»´ú±íͬһÎïÆ·£»
    SuperItemCanChooseCount = 0    #(BYTE SuperItemCanChooseCount)// ÖÕ¼«ÎïÆ·¿ÉÑ¡Ôñ¸öÊý
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x52
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.CTGPrizeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CTGPrizeCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.CTGPrizeList.append(value)
        self.UseMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.UseMoneyPrizeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.UseMoneyPrizeCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.UseMoneyPrizeList.append(value)
        self.TurnItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TurnItemCount):
            temTurnItemList = tagMCActTurntableItem()
            _pos = temTurnItemList.ReadData(_lpData, _pos)
            self.TurnItemList.append(temTurnItemList)
        self.GoodItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GoodItemCount):
            temGoodItemList = tagMCActTurntableItem()
            _pos = temGoodItemList.ReadData(_lpData, _pos)
            self.GoodItemList.append(temGoodItemList)
        self.GoodItemCanChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SuperItemCount):
            temSuperItemList = tagMCActTurntableItem()
            _pos = temSuperItemList.ReadData(_lpData, _pos)
            self.SuperItemList.append(temSuperItemList)
        self.SuperItemCanChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x52
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.CTGPrizeCount = 0
        self.CTGPrizeList = list()
        self.UseMoneyType = 0
        self.UseMoneyPrizeCount = 0
        self.UseMoneyPrizeList = list()
        self.TurnItemCount = 0
        self.TurnItemList = list()
        self.GoodItemCount = 0
        self.GoodItemList = list()
        self.GoodItemCanChooseCount = 0
        self.SuperItemCount = 0
        self.SuperItemList = list()
        self.SuperItemCanChooseCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        length += 4 * self.CTGPrizeCount
        length += 1
        length += 1
        length += 4 * self.UseMoneyPrizeCount
        length += 1
        for i in range(self.TurnItemCount):
            length += self.TurnItemList[i].GetLength()
        length += 1
        for i in range(self.GoodItemCount):
            length += self.GoodItemList[i].GetLength()
        length += 1
        length += 1
        for i in range(self.SuperItemCount):
            length += self.SuperItemList[i].GetLength()
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.CTGPrizeCount)
        for i in range(self.CTGPrizeCount):
            data = CommFunc.WriteDWORD(data, self.CTGPrizeList[i])
        data = CommFunc.WriteBYTE(data, self.UseMoneyType)
        data = CommFunc.WriteBYTE(data, self.UseMoneyPrizeCount)
        for i in range(self.UseMoneyPrizeCount):
            data = CommFunc.WriteDWORD(data, self.UseMoneyPrizeList[i])
        data = CommFunc.WriteBYTE(data, self.TurnItemCount)
        for i in range(self.TurnItemCount):
            data = CommFunc.WriteString(data, self.TurnItemList[i].GetLength(), self.TurnItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.GoodItemCount)
        for i in range(self.GoodItemCount):
            data = CommFunc.WriteString(data, self.GoodItemList[i].GetLength(), self.GoodItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.GoodItemCanChooseCount)
        data = CommFunc.WriteBYTE(data, self.SuperItemCount)
        for i in range(self.SuperItemCount):
            data = CommFunc.WriteString(data, self.SuperItemList[i].GetLength(), self.SuperItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.SuperItemCanChooseCount)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                CTGPrizeCount:%d,
                                CTGPrizeList:%s,
                                UseMoneyType:%d,
                                UseMoneyPrizeCount:%d,
                                UseMoneyPrizeList:%s,
                                TurnItemCount:%d,
                                TurnItemList:%s,
                                GoodItemCount:%d,
                                GoodItemList:%s,
                                GoodItemCanChooseCount:%d,
                                SuperItemCount:%d,
                                SuperItemList:%s,
                                SuperItemCanChooseCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.CTGPrizeCount,
                                "...",
                                self.UseMoneyType,
                                self.UseMoneyPrizeCount,
                                "...",
                                self.TurnItemCount,
                                "...",
                                self.GoodItemCount,
                                "...",
                                self.GoodItemCanChooseCount,
                                self.SuperItemCount,
                                "...",
                                self.SuperItemCanChooseCount
                                )
        return DumpString


m_NAtagMCActTurntableInfo=tagMCActTurntableInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTurntableInfo.Head.Cmd,m_NAtagMCActTurntableInfo.Head.SubCmd))] = m_NAtagMCActTurntableInfo


#------------------------------------------------------
# AA 53 תÅ̻Íæ¼ÒÐÅÏ¢ #tagMCActTurntablePlayerInfo

class  tagMCActTurntablePlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    #»î¶¯±àºÅ
                  ("CanUseCount", c_ubyte),    #¿ÉתÅÌ´ÎÊý
                  ("CTGTotal", c_int),    #ÀۼƳäÖµ¶î¶È
                  ("UseMoneyTotal", c_int),    #ÀÛ¼ÆÏû·Ñ»õ±Ò¶î¶È
                  ("TurnItemState", c_int),    #תÅÌÎïÆ·ÒѳéÖмǼ£¬°´×ªÅÌÎïÆ·±àºÅ¶þ½øÖÆλ´ú±íÊÇ·ñÒѳéÖÐ
                  ("GetItemNum", c_ubyte),    #±¾´Î³éÖеÄÎïÆ·±àºÅ£¬·ÇתÅ̽á¹ûʱΪ0£¬´óÓÚ0ʱΪ֪ͨ±¾´Îתµ½µÄÎïÆ·±àºÅ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x53
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x53
        self.ActNum = 0
        self.CanUseCount = 0
        self.CTGTotal = 0
        self.UseMoneyTotal = 0
        self.TurnItemState = 0
        self.GetItemNum = 0
        return

    def GetLength(self):
        return sizeof(tagMCActTurntablePlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 53 תÅ̻Íæ¼ÒÐÅÏ¢ //tagMCActTurntablePlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                CanUseCount:%d,
                                CTGTotal:%d,
                                UseMoneyTotal:%d,
                                TurnItemState:%d,
                                GetItemNum:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.CanUseCount,
                                self.CTGTotal,
                                self.UseMoneyTotal,
                                self.TurnItemState,
                                self.GetItemNum
                                )
        return DumpString


m_NAtagMCActTurntablePlayerInfo=tagMCActTurntablePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActTurntablePlayerInfo.Cmd,m_NAtagMCActTurntablePlayerInfo.SubCmd))] = m_NAtagMCActTurntablePlayerInfo


#------------------------------------------------------
# AA 1B ÐíÔ¸³ØÍ϶¯½á¹û #tagMCActWishingDragResult

class  tagMCPlayerWishingDragInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("WellType", c_ubyte),    # ¿â 0-¿ÉÑ¡¿â 1-½á¹û¿â
                  ("Index", c_ubyte),    # Ë÷Òý
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ("IsSpecial", c_ubyte),    # ÊÇ·ñ¼«Æ·
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.WellType = 0
        self.Index = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        self.IsSpecial = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerWishingDragInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1B ÐíÔ¸³ØÍ϶¯½á¹û //tagMCActWishingDragResult:
                                WellType:%d,
                                Index:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d,
                                IsSpecial:%d
                                '''\
                                %(
                                self.WellType,
                                self.Index,
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind,
                                self.IsSpecial
                                )
        return DumpString


class  tagMCActWishingDragResult(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)
    InfoList = list()    #(vector<tagMCPlayerWishingDragInfo> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1B
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCPlayerWishingDragInfo()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1B
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCActWishingDragResult=tagMCActWishingDragResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActWishingDragResult.Head.Cmd,m_NAtagMCActWishingDragResult.Head.SubCmd))] = m_NAtagMCActWishingDragResult


#------------------------------------------------------
# AA 19 ÐíÔ¸³Ø»î¶¯ÐÅÏ¢ #tagMCActWishingWellInfo

class  tagMCWishingWellItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ("Mark", c_int),    # ÅÅÐò±êʶ
                  ("Rare", c_ubyte),    # ÕäÏ¡Öµ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        self.Mark = 0
        self.Rare = 0
        return

    def GetLength(self):
        return sizeof(tagMCWishingWellItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 19 ÐíÔ¸³Ø»î¶¯ÐÅÏ¢ //tagMCActWishingWellInfo:
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d,
                                Mark:%d,
                                Rare:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind,
                                self.Mark,
                                self.Rare
                                )
        return DumpString


class  tagMCActWishingWellInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    Count = 0    #(WORD Count)// ÎïÆ·Êý
    WellItemInfo = list()    #(vector<tagMCWishingWellItem> WellItemInfo)// Ëæ»ú¿âÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x19
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temWellItemInfo = tagMCWishingWellItem()
            _pos = temWellItemInfo.ReadData(_lpData, _pos)
            self.WellItemInfo.append(temWellItemInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x19
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.Count = 0
        self.WellItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 1
        length += 1
        length += 2
        length += 2
        for i in range(self.Count):
            length += self.WellItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.WellItemInfo[i].GetLength(), self.WellItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                Count:%d,
                                WellItemInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCActWishingWellInfo=tagMCActWishingWellInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActWishingWellInfo.Head.Cmd,m_NAtagMCActWishingWellInfo.Head.SubCmd))] = m_NAtagMCActWishingWellInfo


#------------------------------------------------------
# AA 1A ÐíÔ¸³Ø»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCActWishingWellPlayerInfo

class  tagMCPlayerWishingWellItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ("IsSpecial", c_ubyte),    # ÊÇ·ñ¼«Æ·
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        self.IsSpecial = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerWishingWellItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1A ÐíÔ¸³Ø»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCActWishingWellPlayerInfo:
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d,
                                IsSpecial:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind,
                                self.IsSpecial
                                )
        return DumpString


class  tagMCActWishingWellPlayerInfo(Structure):
    Head = tagHead()
    FreeStartTime = 0    #(DWORD FreeStartTime)// Ãâ·Ñ¿ªÊ¼µ¹¼Æʱʱ¼ä
    WishCnt = 0    #(DWORD WishCnt)// ÐíÔ¸¸¶·ÑˢдÎÊý
    WellItemCnt = 0    #(BYTE WellItemCnt)//ÐíÔ¸³ØÎïÆ·ÊýÁ¿
    WellItemInfo = list()    #(vector<tagMCPlayerWishingWellItem> WellItemInfo)// Ëæ»ú¿âÎïÆ·ÐÅÏ¢
    CurAwardCnt = 0    #(BYTE CurAwardCnt)// µ±Ç°½±ÀøÎïÆ·ÊýÁ¿
    CurAwardItemInfo = list()    #(vector<tagMCPlayerWishingWellItem> CurAwardItemInfo)// µ±Ç°½±ÀøÎïÆ·
    LastAwardCnt = 0    #(BYTE LastAwardCnt)// ¿ÉÁìÈ¡½±ÀøÎïÆ·ÊýÁ¿
    LastAwardItemInfo = list()    #(vector<tagMCPlayerWishingWellItem> LastAwardItemInfo)// ¿ÉÁìÈ¡½±ÀøÎïÆ·
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1A
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.FreeStartTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WishCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WellItemCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WellItemCnt):
            temWellItemInfo = tagMCPlayerWishingWellItem()
            _pos = temWellItemInfo.ReadData(_lpData, _pos)
            self.WellItemInfo.append(temWellItemInfo)
        self.CurAwardCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CurAwardCnt):
            temCurAwardItemInfo = tagMCPlayerWishingWellItem()
            _pos = temCurAwardItemInfo.ReadData(_lpData, _pos)
            self.CurAwardItemInfo.append(temCurAwardItemInfo)
        self.LastAwardCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.LastAwardCnt):
            temLastAwardItemInfo = tagMCPlayerWishingWellItem()
            _pos = temLastAwardItemInfo.ReadData(_lpData, _pos)
            self.LastAwardItemInfo.append(temLastAwardItemInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1A
        self.FreeStartTime = 0
        self.WishCnt = 0
        self.WellItemCnt = 0
        self.WellItemInfo = list()
        self.CurAwardCnt = 0
        self.CurAwardItemInfo = list()
        self.LastAwardCnt = 0
        self.LastAwardItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        for i in range(self.WellItemCnt):
            length += self.WellItemInfo[i].GetLength()
        length += 1
        for i in range(self.CurAwardCnt):
            length += self.CurAwardItemInfo[i].GetLength()
        length += 1
        for i in range(self.LastAwardCnt):
            length += self.LastAwardItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.FreeStartTime)
        data = CommFunc.WriteDWORD(data, self.WishCnt)
        data = CommFunc.WriteBYTE(data, self.WellItemCnt)
        for i in range(self.WellItemCnt):
            data = CommFunc.WriteString(data, self.WellItemInfo[i].GetLength(), self.WellItemInfo[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.CurAwardCnt)
        for i in range(self.CurAwardCnt):
            data = CommFunc.WriteString(data, self.CurAwardItemInfo[i].GetLength(), self.CurAwardItemInfo[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.LastAwardCnt)
        for i in range(self.LastAwardCnt):
            data = CommFunc.WriteString(data, self.LastAwardItemInfo[i].GetLength(), self.LastAwardItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                FreeStartTime:%d,
                                WishCnt:%d,
                                WellItemCnt:%d,
                                WellItemInfo:%s,
                                CurAwardCnt:%d,
                                CurAwardItemInfo:%s,
                                LastAwardCnt:%d,
                                LastAwardItemInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.FreeStartTime,
                                self.WishCnt,
                                self.WellItemCnt,
                                "...",
                                self.CurAwardCnt,
                                "...",
                                self.LastAwardCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCActWishingWellPlayerInfo=tagMCActWishingWellPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActWishingWellPlayerInfo.Head.Cmd,m_NAtagMCActWishingWellPlayerInfo.Head.SubCmd))] = m_NAtagMCActWishingWellPlayerInfo


#------------------------------------------------------
# AA 59 ÏÉÏ»Ãؾ³³é½±½á¹û #tagMCActXianXiaMJAwardItemResult

class  tagMCActXianXiaMJAwardItemResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    # »î¶¯±àºÅ
                  ("ItemLibType", c_ubyte),    #ÎïÆ·¿âÀàÐÍ£»9-¹Ì¶¨Îª´ó½±¿â£¬·Ç9-²ß»®×Ô¶¨Òå¿â
                  ("ItemID", c_int),    # ×¢Ò⣺ ²»Í¬¿âÎïÆ·ID¿ÉÄÜÏàͬ£¬µ«¸öÊý²»Í¬
                  ("ItemCount", c_ushort),    
                  ("PosNum", c_ubyte),    # ±»³éÖÐʱµÄλÖñàºÅ£¬1~99£¬Ç°¶Ë×Ô¶¨ÒåչʾλÖñàºÅ£¬0´ú±íδ±»³éÖУ»
                  ("TotalTimesNow", c_ubyte),    #µ±Ç°ÒѲú³ö´ÎÊý£¬²»ÏÞÖÆ´ÎÊýʱ²»¼Ç¼£¬¼´Í¬ÑùΪ0
                  ("LotteryScore", c_int),    #µ±Ç°³é½±»ý·Ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x59
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x59
        self.ActNum = 0
        self.ItemLibType = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.PosNum = 0
        self.TotalTimesNow = 0
        self.LotteryScore = 0
        return

    def GetLength(self):
        return sizeof(tagMCActXianXiaMJAwardItemResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 59 ÏÉÏ»Ãؾ³³é½±½á¹û //tagMCActXianXiaMJAwardItemResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                ItemLibType:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                PosNum:%d,
                                TotalTimesNow:%d,
                                LotteryScore:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.ItemLibType,
                                self.ItemID,
                                self.ItemCount,
                                self.PosNum,
                                self.TotalTimesNow,
                                self.LotteryScore
                                )
        return DumpString


m_NAtagMCActXianXiaMJAwardItemResult=tagMCActXianXiaMJAwardItemResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJAwardItemResult.Cmd,m_NAtagMCActXianXiaMJAwardItemResult.SubCmd))] = m_NAtagMCActXianXiaMJAwardItemResult


#------------------------------------------------------
# AA 58 ÏÉÏ»Ãؾ³»î¶¯ÐÅÏ¢ #tagMCActXianXiaMJInfo

class  tagMCActXianXiaMJItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCActXianXiaMJItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 58 ÏÉÏ»Ãؾ³»î¶¯ÐÅÏ¢ //tagMCActXianXiaMJInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCActXianXiaMJAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActXianXiaMJItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActXianXiaMJItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCActXianXiaMJBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCActXianXiaMJItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCActXianXiaMJAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCActXianXiaMJItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCActXianXiaMJAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCActXianXiaMJInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    UseItemID = 0    #(DWORD UseItemID)//ÏûºÄÎïÆ·ID£¬Ä¬ÈÏ1¸ö£»ÏûºÄÎïÆ·»ò»õ±Ò¶þÑ¡Ò»¼´¿É£¬»ò¶¼ÅäÔòÏÈÏûºÄµÀ¾ß£¬²»×ãÔòÏûºÄ»õ±Ò
    MoneyType = 0    #(BYTE MoneyType)//ÏûºÄ»õ±ÒÀàÐÍ
    MoneyValue = 0    #(WORD MoneyValue)//ÏûºÄ»õ±ÒÖµ
    LotteryAddScore = 0    #(WORD LotteryAddScore)//ÿ´Î³é½±¼Ó»ý·Ö
    LayerAddScore = 0    #(WORD LayerAddScore)//ÿ´Î¿ç²ã¼Ó»ý·Ö
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCActXianXiaMJBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x58
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UseItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LotteryAddScore,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LayerAddScore,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCActXianXiaMJBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x58
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.UseItemID = 0
        self.MoneyType = 0
        self.MoneyValue = 0
        self.LotteryAddScore = 0
        self.LayerAddScore = 0
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        length += 2
        length += 4
        length += 1
        length += 2
        length += 2
        length += 2
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteDWORD(data, self.UseItemID)
        data = CommFunc.WriteBYTE(data, self.MoneyType)
        data = CommFunc.WriteWORD(data, self.MoneyValue)
        data = CommFunc.WriteWORD(data, self.LotteryAddScore)
        data = CommFunc.WriteWORD(data, self.LayerAddScore)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                UseItemID:%d,
                                MoneyType:%d,
                                MoneyValue:%d,
                                LotteryAddScore:%d,
                                LayerAddScore:%d,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.IsDayReset,
                                self.LimitLV,
                                self.UseItemID,
                                self.MoneyType,
                                self.MoneyValue,
                                self.LotteryAddScore,
                                self.LayerAddScore,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCActXianXiaMJInfo=tagMCActXianXiaMJInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJInfo.Head.Cmd,m_NAtagMCActXianXiaMJInfo.Head.SubCmd))] = m_NAtagMCActXianXiaMJInfo


#------------------------------------------------------
# AA 79 ÏÉÏ»Ãؾ³²ãÐÅÏ¢ #tagMCActXianXiaMJLayerInfo

class  tagMCActXianXiaMJLayerItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemLibType", c_ubyte),    #ÎïÆ·¿âÀàÐÍ£»9-¹Ì¶¨Îª´ó½±¿â£¬·Ç9-²ß»®×Ô¶¨Òå¿â
                  ("ItemID", c_int),    # ×¢Ò⣺ ²»Í¬¿âÎïÆ·ID¿ÉÄÜÏàͬ£¬µ«¸öÊý²»Í¬
                  ("ItemCount", c_ushort),    
                  ("PosNum", c_ubyte),    # ±»³éÖÐʱµÄλÖñàºÅ£¬1~99£¬Ç°¶Ë×Ô¶¨ÒåչʾλÖñàºÅ£¬0´ú±íδ±»³éÖУ»
                  ("TotalTimesNow", c_ubyte),    #µ±Ç°ÒѲú³ö´ÎÊý£¬²»ÏÞÖÆ´ÎÊýʱ²»¼Ç¼£¬¼´Í¬ÑùΪ0
                  ("TotalTimesMax", c_ubyte),    #×î´ó¿É²ú³ö´ÎÊý£¬0²»ÏÞ
                  ("LayerLimit", c_ubyte),    #´óÓÚµÈÓÚX²ãºó¿É²ú³ö£¬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.ItemLibType = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.PosNum = 0
        self.TotalTimesNow = 0
        self.TotalTimesMax = 0
        self.LayerLimit = 0
        return

    def GetLength(self):
        return sizeof(tagMCActXianXiaMJLayerItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 79 ÏÉÏ»Ãؾ³²ãÐÅÏ¢ //tagMCActXianXiaMJLayerInfo:
                                ItemLibType:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                PosNum:%d,
                                TotalTimesNow:%d,
                                TotalTimesMax:%d,
                                LayerLimit:%d
                                '''\
                                %(
                                self.ItemLibType,
                                self.ItemID,
                                self.ItemCount,
                                self.PosNum,
                                self.TotalTimesNow,
                                self.TotalTimesMax,
                                self.LayerLimit
                                )
        return DumpString


class  tagMCActXianXiaMJLayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    LayerNum = 0    #(WORD LayerNum)//µ±Ç°½±³ØµÚ¼¸²ã
    LotteryScore = 0    #(DWORD LotteryScore)//µ±Ç°³é½±»ý·Ö
    AwardItemCount = 0    #(BYTE AwardItemCount)
    AwardItemList = list()    #(vector<tagMCActXianXiaMJLayerItem> AwardItemList)// ½±³ØÎïÆ·ÁÐ±í£¬ÒÑÉú³ÉµÄ£¬°üº¬ÒÑÑ¡ÔñµÄ´ó½±ÎïÆ·
    SuperItemCount = 0    #(BYTE SuperItemCount)
    SuperItemList = list()    #(vector<tagMCActXianXiaMJLayerItem> SuperItemList)// ´ó½±ÎïÆ·´ýÑ¡Ôñ¿â£¬ÓÉÍæ¼Ò´Ó¿âÖÐÑ¡Ôñ·ÅÈë½±³ØµÄÎïÆ·£»
    SuperItemCanChooseCount = 0    #(BYTE SuperItemCanChooseCount)// ´ó½±ÎïÆ·¿ÉÑ¡Ôñ¸öÊý
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x79
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LayerNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LotteryScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCActXianXiaMJLayerItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.SuperItemCount):
            temSuperItemList = tagMCActXianXiaMJLayerItem()
            _pos = temSuperItemList.ReadData(_lpData, _pos)
            self.SuperItemList.append(temSuperItemList)
        self.SuperItemCanChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x79
        self.ActNum = 0
        self.LayerNum = 0
        self.LotteryScore = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        self.SuperItemCount = 0
        self.SuperItemList = list()
        self.SuperItemCanChooseCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 2
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()
        length += 1
        for i in range(self.SuperItemCount):
            length += self.SuperItemList[i].GetLength()
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteWORD(data, self.LayerNum)
        data = CommFunc.WriteDWORD(data, self.LotteryScore)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.SuperItemCount)
        for i in range(self.SuperItemCount):
            data = CommFunc.WriteString(data, self.SuperItemList[i].GetLength(), self.SuperItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.SuperItemCanChooseCount)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                LayerNum:%d,
                                LotteryScore:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s,
                                SuperItemCount:%d,
                                SuperItemList:%s,
                                SuperItemCanChooseCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.LayerNum,
                                self.LotteryScore,
                                self.AwardItemCount,
                                "...",
                                self.SuperItemCount,
                                "...",
                                self.SuperItemCanChooseCount
                                )
        return DumpString


m_NAtagMCActXianXiaMJLayerInfo=tagMCActXianXiaMJLayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJLayerInfo.Head.Cmd,m_NAtagMCActXianXiaMJLayerInfo.Head.SubCmd))] = m_NAtagMCActXianXiaMJLayerInfo


#------------------------------------------------------
# AA 87 ÔËÊƻÐÅÏ¢ #tagMCActYunshiInfo

class  tagMCActYunshiInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)// »î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    TreasureType = 0    #(BYTE TreasureType)// »î¶¯Ñ°±¦ÀàÐÍ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x87
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TreasureType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x87
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.ResetType = 0
        self.LimitLV = 0
        self.TreasureType = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.TreasureType)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                ResetType:%d,
                                LimitLV:%d,
                                TreasureType:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.ResetType,
                                self.LimitLV,
                                self.TreasureType
                                )
        return DumpString


m_NAtagMCActYunshiInfo=tagMCActYunshiInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActYunshiInfo.Head.Cmd,m_NAtagMCActYunshiInfo.Head.SubCmd))] = m_NAtagMCActYunshiInfo


#------------------------------------------------------
# AA 15 ÏɽçÊ¢µäÈ«ÃñÀ´àËÍæ¼ÒÐÅÏ¢ #tagMCAllPeoplePartyInfo

class  tagMCAllPeoplePartyCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ActID", c_int),    #»î¶¯ID
                  ("CurTimes", 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.ActID = 0
        self.CurTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCAllPeoplePartyCount)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 15 ÏɽçÊ¢µäÈ«ÃñÀ´àËÍæ¼ÒÐÅÏ¢ //tagMCAllPeoplePartyInfo:
                                ActID:%d,
                                CurTimes:%d
                                '''\
                                %(
                                self.ActID,
                                self.CurTimes
                                )
        return DumpString


class  tagMCAllPeoplePartyInfo(Structure):
    Head = tagHead()
    CurPoint = 0    #(DWORD CurPoint)//µ±Ç°×ܵãÊý
    AwardRecord = 0    #(DWORD AwardRecord)//Áì½±¼Ç¼ °´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡
    Count = 0    #(BYTE Count)
    BuyCountList = list()    #(vector<tagMCAllPeoplePartyCount> BuyCountList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CurPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBuyCountList = tagMCAllPeoplePartyCount()
            _pos = temBuyCountList.ReadData(_lpData, _pos)
            self.BuyCountList.append(temBuyCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x15
        self.CurPoint = 0
        self.AwardRecord = 0
        self.Count = 0
        self.BuyCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.BuyCountList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.CurPoint)
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BuyCountList[i].GetLength(), self.BuyCountList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CurPoint:%d,
                                AwardRecord:%d,
                                Count:%d,
                                BuyCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CurPoint,
                                self.AwardRecord,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCAllPeoplePartyInfo=tagMCAllPeoplePartyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAllPeoplePartyInfo.Head.Cmd,m_NAtagMCAllPeoplePartyInfo.Head.SubCmd))] = m_NAtagMCAllPeoplePartyInfo


#------------------------------------------------------
# AA 32 ¿ç·þ³äÖµÅÅÐлÐÅÏ¢ #tagMCCACTGBillboardInfo

class  tagMCCACTGBillboardAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    # ÊÇ·ñÅÄÆ·
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCACTGBillboardAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 32 ¿ç·þ³äÖµÅÅÐлÐÅÏ¢ //tagMCCACTGBillboardInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCACTGBillboardDabiao(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý 0~31
    NeedRMB = 0    #(DWORD NeedRMB)// ËùÐè³äÖµRMB
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCACTGBillboardAwardItem> AwardItemList)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedRMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCCACTGBillboardAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedRMB = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedRMB)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedRMB:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedRMB,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCCACTGBillboardOrder(Structure):
    OrderA = 0    #(BYTE OrderA)// Ãû´ÎA
    OrderB = 0    #(BYTE OrderB)// ÖÁÃû´ÎB
    NeedRMB = 0    #(DWORD NeedRMB)// ËùÐè³äÖµRMB£¬Î´´ï±êµÄ¸ÃÃû´Î¿Õ£¬ÅÅÃûºóÃæµÄÍæ¼ÒÏòÏÂ˳ÑÓ
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCACTGBillboardAwardItem> AwardItemList)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.OrderA,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderB,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedRMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCCACTGBillboardAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.OrderA = 0
        self.OrderB = 0
        self.NeedRMB = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.OrderA)
        data = CommFunc.WriteBYTE(data, self.OrderB)
        data = CommFunc.WriteDWORD(data, self.NeedRMB)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                OrderA:%d,
                                OrderB:%d,
                                NeedRMB:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.OrderA,
                                self.OrderB,
                                self.NeedRMB,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCCACTGBillboardTempInfo(Structure):
    TemplateID = 0    #(BYTE TemplateID)// »î¶¯Ä£°åID
    DabiaoAwardCount = 0    #(BYTE DabiaoAwardCount)// ´ï±ê½±ÀøµµÊý
    DabiaoAwardInfo = list()    #(vector<tagMCCACTGBillboardDabiao> DabiaoAwardInfo)// ´ï±ê½±ÀøÐÅÏ¢
    OrderAwardCount = 0    #(BYTE OrderAwardCount)// ÅÅÐн±ÀøµµÊý
    OrderAwardInfo = list()    #(vector<tagMCCACTGBillboardOrder> OrderAwardInfo)// ÅÅÐн±ÀøÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TemplateID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.DabiaoAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DabiaoAwardCount):
            temDabiaoAwardInfo = tagMCCACTGBillboardDabiao()
            _pos = temDabiaoAwardInfo.ReadData(_lpData, _pos)
            self.DabiaoAwardInfo.append(temDabiaoAwardInfo)
        self.OrderAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.OrderAwardCount):
            temOrderAwardInfo = tagMCCACTGBillboardOrder()
            _pos = temOrderAwardInfo.ReadData(_lpData, _pos)
            self.OrderAwardInfo.append(temOrderAwardInfo)
        return _pos

    def Clear(self):
        self.TemplateID = 0
        self.DabiaoAwardCount = 0
        self.DabiaoAwardInfo = list()
        self.OrderAwardCount = 0
        self.OrderAwardInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        for i in range(self.DabiaoAwardCount):
            length += self.DabiaoAwardInfo[i].GetLength()
        length += 1
        for i in range(self.OrderAwardCount):
            length += self.OrderAwardInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.TemplateID)
        data = CommFunc.WriteBYTE(data, self.DabiaoAwardCount)
        for i in range(self.DabiaoAwardCount):
            data = CommFunc.WriteString(data, self.DabiaoAwardInfo[i].GetLength(), self.DabiaoAwardInfo[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.OrderAwardCount)
        for i in range(self.OrderAwardCount):
            data = CommFunc.WriteString(data, self.OrderAwardInfo[i].GetLength(), self.OrderAwardInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TemplateID:%d,
                                DabiaoAwardCount:%d,
                                DabiaoAwardInfo:%s,
                                OrderAwardCount:%d,
                                OrderAwardInfo:%s
                                '''\
                                %(
                                self.TemplateID,
                                self.DabiaoAwardCount,
                                "...",
                                self.OrderAwardCount,
                                "..."
                                )
        return DumpString


class  tagMCCACTGBillboardInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    GroupValue1 = 0    #(BYTE GroupValue1)// »î¶¯°ñµ¥·Ö×éÖµ1£¬ÓÃÓÚ²éѯ¶ÔÓ¦°ñµ¥
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    TemplateID = 0    #(BYTE TemplateID)// µ±Ç°»î¶¯Ä£°åID
    TemplateCount = 0    #(BYTE TemplateCount)
    TempInfo = list()    #(vector<tagMCCACTGBillboardTempInfo> TempInfo)// Ä£°åÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x32
        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.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.TemplateID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TemplateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TemplateCount):
            temTempInfo = tagMCCACTGBillboardTempInfo()
            _pos = temTempInfo.ReadData(_lpData, _pos)
            self.TempInfo.append(temTempInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x32
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.GroupValue1 = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.TemplateID = 0
        self.TemplateCount = 0
        self.TempInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 1
        length += 10
        length += 10
        length += 1
        length += 1
        for i in range(self.TemplateCount):
            length += self.TempInfo[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.GroupValue1)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.TemplateID)
        data = CommFunc.WriteBYTE(data, self.TemplateCount)
        for i in range(self.TemplateCount):
            data = CommFunc.WriteString(data, self.TempInfo[i].GetLength(), self.TempInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                GroupValue1:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                TemplateID:%d,
                                TemplateCount:%d,
                                TempInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.GroupValue1,
                                self.StartDate,
                                self.EndtDate,
                                self.TemplateID,
                                self.TemplateCount,
                                "..."
                                )
        return DumpString


m_NAtagMCCACTGBillboardInfo=tagMCCACTGBillboardInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCACTGBillboardInfo.Head.Cmd,m_NAtagMCCACTGBillboardInfo.Head.SubCmd))] = m_NAtagMCCACTGBillboardInfo


#------------------------------------------------------
# AA 33 ¿ç·þ³äÖµÅÅÐлÍæ¼ÒÐÅÏ¢ #tagMCCACTGBillboardPlayerInfo

class  tagMCCACTGBillboardPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CTGRMBTotal", c_int),    # »î¶¯ÒÑÀۼƳäÖµRMB
                  ("DabiaoAwardRecord", c_int),    # ´ï±ê½±Àø¼Ç¼£¬Óë´ï±ê½±ÀøË÷Òýλ»òÔËËãÅжÏÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x33
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x33
        self.CTGRMBTotal = 0
        self.DabiaoAwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCCACTGBillboardPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 33 ¿ç·þ³äÖµÅÅÐлÍæ¼ÒÐÅÏ¢ //tagMCCACTGBillboardPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                CTGRMBTotal:%d,
                                DabiaoAwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CTGRMBTotal,
                                self.DabiaoAwardRecord
                                )
        return DumpString


m_NAtagMCCACTGBillboardPlayerInfo=tagMCCACTGBillboardPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCACTGBillboardPlayerInfo.Cmd,m_NAtagMCCACTGBillboardPlayerInfo.SubCmd))] = m_NAtagMCCACTGBillboardPlayerInfo


#------------------------------------------------------
# AA 09 Ïû·Ñ·µÀû»î¶¯ÐÅÏ¢ #tagMCCostRebateInfo

class  tagMCCostRebateAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_int),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCostRebateAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 09 Ïû·Ñ·µÀû»î¶¯ÐÅÏ¢ //tagMCCostRebateInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCostRebateAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)// ½±ÀøË÷Òý 0~31
    NeedGold = 0    #(DWORD NeedGold)// ËùÐèÏÉÓñÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItem = list()    #(vector<tagMCCostRebateAwardItem> AwardItem)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedGold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItem = tagMCCostRebateAwardItem()
            _pos = temAwardItem.ReadData(_lpData, _pos)
            self.AwardItem.append(temAwardItem)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedGold = 0
        self.AwardItemCount = 0
        self.AwardItem = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItem[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteDWORD(data, self.NeedGold)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItem[i].GetLength(), self.AwardItem[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedGold:%d,
                                AwardItemCount:%d,
                                AwardItem:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedGold,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCCostRebateAwardDay(Structure):
    AwardCount = 0    #(BYTE AwardCount)// ½±ÀøµµÊý
    AwardInfo = list()    #(vector<tagMCCostRebateAward> AwardInfo)// ½±ÀøµµÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardInfo = tagMCCostRebateAward()
            _pos = temAwardInfo.ReadData(_lpData, _pos)
            self.AwardInfo.append(temAwardInfo)
        return _pos

    def Clear(self):
        self.AwardCount = 0
        self.AwardInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardInfo[i].GetLength(), self.AwardInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardCount:%d,
                                AwardInfo:%s
                                '''\
                                %(
                                self.AwardCount,
                                "..."
                                )
        return DumpString


class  tagMCCostRebateInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    AwardDays = 0    #(BYTE AwardDays)
    AwardDayInfo = list()    #(vector<tagMCCostRebateAwardDay> AwardDayInfo)//ÿÌì¶ÔÓ¦·µÀûÐÅÏ¢; Èç¹ûÖ»ÓÐÒ»Ì죬µ«ÊǻÓжàÌ죬Ôò´ú±íÿÌì½±Àø¶¼Ò»Ñù
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardDays):
            temAwardDayInfo = tagMCCostRebateAwardDay()
            _pos = temAwardDayInfo.ReadData(_lpData, _pos)
            self.AwardDayInfo.append(temAwardDayInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x09
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.IsDayReset = 0
        self.LimitLV = 0
        self.AwardDays = 0
        self.AwardDayInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.AwardDays):
            length += self.AwardDayInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.AwardDays)
        for i in range(self.AwardDays):
            data = CommFunc.WriteString(data, self.AwardDayInfo[i].GetLength(), self.AwardDayInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                AwardDays:%d,
                                AwardDayInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.IsDayReset,
                                self.LimitLV,
                                self.AwardDays,
                                "..."
                                )
        return DumpString


m_NAtagMCCostRebateInfo=tagMCCostRebateInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCostRebateInfo.Head.Cmd,m_NAtagMCCostRebateInfo.Head.SubCmd))] = m_NAtagMCCostRebateInfo


#------------------------------------------------------
# AA 10 Ïû·Ñ·µÀûÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCCostRebatePlayerInfo

class  tagMCCostRebatePlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    #»î¶¯±àºÅ
                  ("CostGoldTotal", c_int),    #±¾´Î»î¶¯ÒÑÀÛ¼ÆÏû·ÑÏÉÓñÊý
                  ("AwardRecord", c_int),    #·µÀû½±ÀøÁì½±¼Ç¼£¬°´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        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 = 0xAA
        self.SubCmd = 0x10
        self.ActNum = 0
        self.CostGoldTotal = 0
        self.AwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCCostRebatePlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 10 Ïû·Ñ·µÀûÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCCostRebatePlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                CostGoldTotal:%d,
                                AwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.CostGoldTotal,
                                self.AwardRecord
                                )
        return DumpString


m_NAtagMCCostRebatePlayerInfo=tagMCCostRebatePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCostRebatePlayerInfo.Cmd,m_NAtagMCCostRebatePlayerInfo.SubCmd))] = m_NAtagMCCostRebatePlayerInfo


#------------------------------------------------------
# AA 34 ¿ç·þÈ«Ãñ³äÖµ»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCCrossActAllRechargePlayerInfo

class  tagMCCrossActAllRechargePlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CTGRMBTotal", c_int),    # »î¶¯ÒÑÀۼƳäÖµRMB
                  ("AwardRecord", c_int),    # ½±Àø¼Ç¼£¬¸ù¾Ý½±ÀøË÷Òýλ»òÔËËãÅжÏÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x34
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x34
        self.CTGRMBTotal = 0
        self.AwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossActAllRechargePlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 34 ¿ç·þÈ«Ãñ³äÖµ»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCCrossActAllRechargePlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                CTGRMBTotal:%d,
                                AwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CTGRMBTotal,
                                self.AwardRecord
                                )
        return DumpString


m_NAtagMCCrossActAllRechargePlayerInfo=tagMCCrossActAllRechargePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActAllRechargePlayerInfo.Cmd,m_NAtagMCCrossActAllRechargePlayerInfo.SubCmd))] = m_NAtagMCCrossActAllRechargePlayerInfo


#------------------------------------------------------
# AA 76 BossÀúÁ·¿ç·þ»î¶¯ÐÅÏ¢ #tagMCCrossActBossTrialInfo

class  tagMCCrossActBossTrialItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossActBossTrialItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 76 BossÀúÁ·¿ç·þ»î¶¯ÐÅÏ¢ //tagMCCrossActBossTrialInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCrossActBossTrialAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActBossTrialItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCCrossActBossTrialBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> AwardItemList)// ½±ÀøÎïÆ·ÁÐ±í£¬µ±ÏÉÃË°ñʱ£¬Èç¹ûÓиý±ÀøÔò´ú±íÃËÖ÷½±Àø£¬·ñÔòĬÈϾùΪ³ÉÔ±½±Àø
    MemCount = 0    #(BYTE MemCount)// ³ÉÔ±½±ÀøÎïÆ·Êý
    MemAwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> MemAwardItemList)// ³ÉÔ±½±ÀøÎïÆ·ÁÐ±í£¬½öÏÉÃË°ñʱÓÐЧ
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCCrossActBossTrialAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActBossTrialItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.MemCount):
            temMemAwardItemList = tagMCCrossActBossTrialItem()
            _pos = temMemAwardItemList.ReadData(_lpData, _pos)
            self.MemAwardItemList.append(temMemAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCCrossActBossTrialAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.MemCount = 0
        self.MemAwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 1
        for i in range(self.MemCount):
            length += self.MemAwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.MemCount)
        for i in range(self.MemCount):
            data = CommFunc.WriteString(data, self.MemAwardItemList[i].GetLength(), self.MemAwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                MemCount:%d,
                                MemAwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.MemCount,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCCrossActBossTrialInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    GroupValue1 = 0    #(BYTE GroupValue1)// »î¶¯°ñµ¥·Ö×éÖµ1£¬ÓÃÓÚ²éѯ¶ÔÓ¦°ñµ¥
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActBossTrialBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    FamilyBillCount = 0    #(BYTE FamilyBillCount)
    FamilyBillboardInfoList = list()    #(vector<tagMCCrossActBossTrialBillard> FamilyBillboardInfoList)// ÏÉÃË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x76
        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.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCCrossActBossTrialBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        self.FamilyBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.FamilyBillCount):
            temFamilyBillboardInfoList = tagMCCrossActBossTrialBillard()
            _pos = temFamilyBillboardInfoList.ReadData(_lpData, _pos)
            self.FamilyBillboardInfoList.append(temFamilyBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x76
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.GroupValue1 = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.IsDayReset = 0
        self.ResetType = 0
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        self.FamilyBillCount = 0
        self.FamilyBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        length += 1
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[i].GetLength()
        length += 1
        for i in range(self.FamilyBillCount):
            length += self.FamilyBillboardInfoList[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.GroupValue1)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.FamilyBillCount)
        for i in range(self.FamilyBillCount):
            data = CommFunc.WriteString(data, self.FamilyBillboardInfoList[i].GetLength(), self.FamilyBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                GroupValue1:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                IsDayReset:%d,
                                ResetType:%d,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s,
                                FamilyBillCount:%d,
                                FamilyBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.GroupValue1,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.IsDayReset,
                                self.ResetType,
                                self.PersonalBillCount,
                                "...",
                                self.FamilyBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCCrossActBossTrialInfo=tagMCCrossActBossTrialInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActBossTrialInfo.Head.Cmd,m_NAtagMCCrossActBossTrialInfo.Head.SubCmd))] = m_NAtagMCCrossActBossTrialInfo


#------------------------------------------------------
# AA 83 ¹Å±¦Ñø³É¿ç·þ»î¶¯ÐÅÏ¢ #tagMCCrossActGubaoInfo

class  tagMCCrossActGubaoItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossActGubaoItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 83 ¹Å±¦Ñø³É¿ç·þ»î¶¯ÐÅÏ¢ //tagMCCrossActGubaoInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCrossActGubaoAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActGubaoItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActGubaoItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCCrossActGubaoBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActGubaoItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCCrossActGubaoAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActGubaoItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCCrossActGubaoAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCCrossActGubaoInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    GroupValue1 = 0    #(BYTE GroupValue1)// »î¶¯°ñµ¥·Ö×éÖµ1£¬ÓÃÓÚ²éѯ¶ÔÓ¦°ñµ¥
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActGubaoBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x83
        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.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCCrossActGubaoBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x83
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.GroupValue1 = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[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.GroupValue1)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                GroupValue1:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.GroupValue1,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCCrossActGubaoInfo=tagMCCrossActGubaoInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActGubaoInfo.Head.Cmd,m_NAtagMCCrossActGubaoInfo.Head.SubCmd))] = m_NAtagMCCrossActGubaoInfo


#------------------------------------------------------
# AA 86 Æï³èÑø³É¿ç·þ»î¶¯ÐÅÏ¢ #tagMCCrossActHorsePetTrainInfo

class  tagMCCrossActHorsePetTrainItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossActHorsePetTrainItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 86 Æï³èÑø³É¿ç·þ»î¶¯ÐÅÏ¢ //tagMCCrossActHorsePetTrainInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCrossActHorsePetTrainAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActHorsePetTrainItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActHorsePetTrainItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCCrossActHorsePetTrainBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActHorsePetTrainItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCCrossActHorsePetTrainAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActHorsePetTrainItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCCrossActHorsePetTrainAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCCrossActHorsePetTrainInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    GroupValue1 = 0    #(BYTE GroupValue1)// »î¶¯°ñµ¥·Ö×éÖµ1£¬ÓÃÓÚ²éѯ¶ÔÓ¦°ñµ¥
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActHorsePetTrainBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x86
        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.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCCrossActHorsePetTrainBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x86
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.GroupValue1 = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[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.GroupValue1)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                GroupValue1:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.GroupValue1,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCCrossActHorsePetTrainInfo=tagMCCrossActHorsePetTrainInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActHorsePetTrainInfo.Head.Cmd,m_NAtagMCCrossActHorsePetTrainInfo.Head.SubCmd))] = m_NAtagMCCrossActHorsePetTrainInfo


#------------------------------------------------------
# AA 80 ÏÉÏ»Ãؾ³¿ç·þ»î¶¯ÐÅÏ¢ #tagMCCrossActXianXiaMJInfo

class  tagMCCrossActXianXiaMJItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossActXianXiaMJItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 80 ÏÉÏ»Ãؾ³¿ç·þ»î¶¯ÐÅÏ¢ //tagMCCrossActXianXiaMJInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCCrossActXianXiaMJAwardEx(Structure):
    NeedScore = 0    #(DWORD NeedScore)// ¶îÍâ½±ÀøËùÐè»ý·Ö
    Count = 0    #(BYTE Count)// ¶îÍâ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActXianXiaMJItem> AwardItemList)// ¶îÍâ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActXianXiaMJItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.NeedScore = 0
        self.Count = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                NeedScore:%d,
                                Count:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.NeedScore,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCCrossActXianXiaMJBillard(Structure):
    Rank = 0    #(DWORD Rank)// Ãû´Î£¬1-´ú±íµÚÒ»Ãû£»Ö§³Ö¿ä¶Î£¬Èç1£¬3 ´ú±íµÚ1Ãû£¬µÚ2~3Ãû
    Count = 0    #(BYTE Count)// ½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCCrossActXianXiaMJItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    NeedScore = 0    #(DWORD NeedScore)// ÉÏ°ñËùÐè»ý·Ö
    CountEx = 0    #(BYTE CountEx)// ¶îÍâ½±ÀøÊý
    AwardItemExList = list()    #(vector<tagMCCrossActXianXiaMJAwardEx> AwardItemExList)// ¶îÍâ½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temAwardItemList = tagMCCrossActXianXiaMJItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.CountEx):
            temAwardItemExList = tagMCCrossActXianXiaMJAwardEx()
            _pos = temAwardItemExList.ReadData(_lpData, _pos)
            self.AwardItemExList.append(temAwardItemExList)
        return _pos

    def Clear(self):
        self.Rank = 0
        self.Count = 0
        self.AwardItemList = list()
        self.NeedScore = 0
        self.CountEx = 0
        self.AwardItemExList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.AwardItemList[i].GetLength()
        length += 4
        length += 1
        for i in range(self.CountEx):
            length += self.AwardItemExList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.Rank)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        data = CommFunc.WriteDWORD(data, self.NeedScore)
        data = CommFunc.WriteBYTE(data, self.CountEx)
        for i in range(self.CountEx):
            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Rank:%d,
                                Count:%d,
                                AwardItemList:%s,
                                NeedScore:%d,
                                CountEx:%d,
                                AwardItemExList:%s
                                '''\
                                %(
                                self.Rank,
                                self.Count,
                                "...",
                                self.NeedScore,
                                self.CountEx,
                                "..."
                                )
        return DumpString


class  tagMCCrossActXianXiaMJInfo(Structure):
    Head = tagHead()
    ServerInfoLen = 0    #(BYTE ServerInfoLen)
    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//¿ª·Å¸Ã»î¶¯µÄ·þÎñÆ÷ID·¶Î§ÁÐ±í£¬json¸ñʽ [[IDA, IDB], ...]£¬ [] Ϊȫ·þ
    GroupValue1 = 0    #(BYTE GroupValue1)// »î¶¯°ñµ¥·Ö×éÖµ1£¬ÓÃÓÚ²éѯ¶ÔÓ¦°ñµ¥
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    JoinStartTime = ""    #(char JoinStartTime[5])// ²ÎÓ뿪ʼʱ¼äµã mm:ss
    JoinEndTime = ""    #(char JoinEndTime[5])// ²ÎÓë½áÊøʱ¼äµã mm:ss
    IsDayReset = 0    #(BYTE IsDayReset)// ÊÇ·ñÿÌìÖØÖÃ
    PersonalBillCount = 0    #(BYTE PersonalBillCount)
    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActXianXiaMJBillard> PersonalBillboardInfoList)// ¸öÈË°ñµ¥½±ÀøÐÅÏ¢ÁÐ±í£¬Èç¹ûûÓдú±í±¾´Î»î¶¯Ã»Óиðñ½±Àø
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x80
        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.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PersonalBillCount):
            temPersonalBillboardInfoList = tagMCCrossActXianXiaMJBillard()
            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)
            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x80
        self.ServerInfoLen = 0
        self.ServerIDRangeInfo = ""
        self.GroupValue1 = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.JoinStartTime = ""
        self.JoinEndTime = ""
        self.IsDayReset = 0
        self.PersonalBillCount = 0
        self.PersonalBillboardInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.ServerIDRangeInfo)
        length += 1
        length += 10
        length += 10
        length += 5
        length += 5
        length += 1
        length += 1
        for i in range(self.PersonalBillCount):
            length += self.PersonalBillboardInfoList[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.GroupValue1)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteString(data, 5, self.JoinStartTime)
        data = CommFunc.WriteString(data, 5, self.JoinEndTime)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)
        for i in range(self.PersonalBillCount):
            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ServerInfoLen:%d,
                                ServerIDRangeInfo:%s,
                                GroupValue1:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                JoinStartTime:%s,
                                JoinEndTime:%s,
                                IsDayReset:%d,
                                PersonalBillCount:%d,
                                PersonalBillboardInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ServerInfoLen,
                                self.ServerIDRangeInfo,
                                self.GroupValue1,
                                self.StartDate,
                                self.EndtDate,
                                self.JoinStartTime,
                                self.JoinEndTime,
                                self.IsDayReset,
                                self.PersonalBillCount,
                                "..."
                                )
        return DumpString


m_NAtagMCCrossActXianXiaMJInfo=tagMCCrossActXianXiaMJInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActXianXiaMJInfo.Head.Cmd,m_NAtagMCCrossActXianXiaMJInfo.Head.SubCmd))] = m_NAtagMCCrossActXianXiaMJInfo


#------------------------------------------------------
# AA 25 ÿÈÕÀñ°ü»î¶¯ÐÅÏ¢ #tagMCDailyGiftbagInfo

class  tagMCDailyGiftbagItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", 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.ItemCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCDailyGiftbagItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 25 ÿÈÕÀñ°ü»î¶¯ÐÅÏ¢ //tagMCDailyGiftbagInfo:
                                ItemID:%d,
                                ItemCount:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount
                                )
        return DumpString


class  tagMCDailyGiftbag(Structure):
    GiftID = 0    #(DWORD GiftID)//Àñ°üID£¬0ΪÃâ·Ñ
    OrderInfoLen = 0    #(BYTE OrderInfoLen)
    OrderInfo = ""    #(String OrderInfo)//ÉÌÆ·±àºÅ
    BuyCountLimit = 0    #(BYTE BuyCountLimit)//ÏÞ¹ºÊý
    RMB = 0    #(DWORD RMB)//ËùÐèRMB£¬Ôª
    GiftItemCount = 0    #(BYTE GiftItemCount)// Àñ°üÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCDailyGiftbagItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    Discount = 0    #(WORD Discount)// ÕÛ¿ÛÁ¦¶È°Ù·Ö±È
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.OrderInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderInfoLen)
        self.BuyCountLimit,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftItemCount):
            temItemInfo = tagMCDailyGiftbagItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        self.Discount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.GiftID = 0
        self.OrderInfoLen = 0
        self.OrderInfo = ""
        self.BuyCountLimit = 0
        self.RMB = 0
        self.GiftItemCount = 0
        self.ItemInfo = list()
        self.Discount = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += len(self.OrderInfo)
        length += 1
        length += 4
        length += 1
        for i in range(self.GiftItemCount):
            length += self.ItemInfo[i].GetLength()
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.GiftID)
        data = CommFunc.WriteBYTE(data, self.OrderInfoLen)
        data = CommFunc.WriteString(data, self.OrderInfoLen, self.OrderInfo)
        data = CommFunc.WriteBYTE(data, self.BuyCountLimit)
        data = CommFunc.WriteDWORD(data, self.RMB)
        data = CommFunc.WriteBYTE(data, self.GiftItemCount)
        for i in range(self.GiftItemCount):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.Discount)
        return data

    def OutputString(self):
        DumpString = '''
                                GiftID:%d,
                                OrderInfoLen:%d,
                                OrderInfo:%s,
                                BuyCountLimit:%d,
                                RMB:%d,
                                GiftItemCount:%d,
                                ItemInfo:%s,
                                Discount:%d
                                '''\
                                %(
                                self.GiftID,
                                self.OrderInfoLen,
                                self.OrderInfo,
                                self.BuyCountLimit,
                                self.RMB,
                                self.GiftItemCount,
                                "...",
                                self.Discount
                                )
        return DumpString


class  tagMCDailyGiftbagInfo(Structure):
    Head = tagHead()
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    GiftbagCount = 0    #(BYTE GiftbagCount)// Àñ°üÊý
    GiftbagInfo = list()    #(vector<tagMCDailyGiftbag> GiftbagInfo)// Àñ°üÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x25
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagInfo = tagMCDailyGiftbag()
            _pos = temGiftbagInfo.ReadData(_lpData, _pos)
            self.GiftbagInfo.append(temGiftbagInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x25
        self.LimitLV = 0
        self.GiftbagCount = 0
        self.GiftbagInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagInfo[i].GetLength(), self.GiftbagInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                LimitLV:%d,
                                GiftbagCount:%d,
                                GiftbagInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.LimitLV,
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


m_NAtagMCDailyGiftbagInfo=tagMCDailyGiftbagInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDailyGiftbagInfo.Head.Cmd,m_NAtagMCDailyGiftbagInfo.Head.SubCmd))] = m_NAtagMCDailyGiftbagInfo


#------------------------------------------------------
# AA 26 ÿÈÕÀñ°üÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCDailyGiftbagPlayerInfo

class  tagMCDailyGiftbagBuyCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GiftbagID", c_int),    #Àñ°üID
                  ("BuyCount", 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.GiftbagID = 0
        self.BuyCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCDailyGiftbagBuyCount)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 26 ÿÈÕÀñ°üÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCDailyGiftbagPlayerInfo:
                                GiftbagID:%d,
                                BuyCount:%d
                                '''\
                                %(
                                self.GiftbagID,
                                self.BuyCount
                                )
        return DumpString


class  tagMCDailyGiftbagPlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    BuyCountList = list()    #(vector<tagMCDailyGiftbagBuyCount> BuyCountList)//Àñ°ü¹ºÂò´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x26
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBuyCountList = tagMCDailyGiftbagBuyCount()
            _pos = temBuyCountList.ReadData(_lpData, _pos)
            self.BuyCountList.append(temBuyCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x26
        self.Count = 0
        self.BuyCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.BuyCountList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BuyCountList[i].GetLength(), self.BuyCountList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                BuyCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCDailyGiftbagPlayerInfo=tagMCDailyGiftbagPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDailyGiftbagPlayerInfo.Head.Cmd,m_NAtagMCDailyGiftbagPlayerInfo.Head.SubCmd))] = m_NAtagMCDailyGiftbagPlayerInfo


#------------------------------------------------------
# AA 03 ÿÈÕ´ò°üÖ±¹ºÀñ°ü #tagMCDailyPackBuyGiftInfo

class  tagMCDailyPackBuyGiftInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PackBuyTime", c_int),    # ´ò°ü¹ºÂòµÄʱ¼ä´Á£¬Èç¹ûÓиÃÖµ£¬´ú±íÒѾ­Ò»´ÎÐÔ´ò°ü¹ºÂòÁË£¬¿É¸ù¾Ý´Îʱ¼ä´ÁËã³öµ±Ç°Êǵڼ¸Ìì
                  ("BuyStateToday", c_int),    # ½ñÈÕÀñ°ü¹ºÂò״̬£¬°´Àñ°üË÷Òý¶þ½øÖÆλ¼ÆËã´ú±íÊÇ·ñÒѹºÂò£¬½ö·Ç´ò°ü¹ºÂò״̬ÏÂÓÐÓÃ
                  ("AwardState", c_int),    # ½ñÈÕÀñ°üÁ콱״̬£¬°´Àñ°üË÷Òý¶þ½øÖÆλ¼ÆËã´ú±íÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x03
        self.PackBuyTime = 0
        self.BuyStateToday = 0
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCDailyPackBuyGiftInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 03 ÿÈÕ´ò°üÖ±¹ºÀñ°ü //tagMCDailyPackBuyGiftInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                PackBuyTime:%d,
                                BuyStateToday:%d,
                                AwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PackBuyTime,
                                self.BuyStateToday,
                                self.AwardState
                                )
        return DumpString


m_NAtagMCDailyPackBuyGiftInfo=tagMCDailyPackBuyGiftInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDailyPackBuyGiftInfo.Cmd,m_NAtagMCDailyPackBuyGiftInfo.SubCmd))] = m_NAtagMCDailyPackBuyGiftInfo


#------------------------------------------------------
# AA 24 ÿÈÕÃâ·ÑÖ±¹ºÀñ°üÐÅÏ¢ #tagMCDayFreeGoldGiftState

class  tagMCDayFreeGoldGiftState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DayFreeGoldGiftState", c_ubyte),    #ÿÈÕÃâ·ÑÖ±¹ºÀñ°üÊÇ·ñÒÑÁì½± 0-δÁì 1-ÒÑÁì
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x24
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x24
        self.DayFreeGoldGiftState = 0
        return

    def GetLength(self):
        return sizeof(tagMCDayFreeGoldGiftState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 24 ÿÈÕÃâ·ÑÖ±¹ºÀñ°üÐÅÏ¢ //tagMCDayFreeGoldGiftState:
                                Cmd:%s,
                                SubCmd:%s,
                                DayFreeGoldGiftState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DayFreeGoldGiftState
                                )
        return DumpString


m_NAtagMCDayFreeGoldGiftState=tagMCDayFreeGoldGiftState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDayFreeGoldGiftState.Cmd,m_NAtagMCDayFreeGoldGiftState.SubCmd))] = m_NAtagMCDayFreeGoldGiftState


#------------------------------------------------------
# AA 42 ½ÚÈյǼ½±Àø»î¶¯ÐÅÏ¢ #tagMCFeastLoginInfo

class  tagMCFeastLoginDayAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastLoginDayAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 42 ½ÚÈյǼ½±Àø»î¶¯ÐÅÏ¢ //tagMCFeastLoginInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCFeastLoginDayAward(Structure):
    DayNum = 0    #(BYTE DayNum)//Ìì±àºÅ£¬´Ó1¿ªÊ¼£¬»î¶¯µÚXÌìÖ»ÄÜÁì¶ÔÓ¦µÚXÌìµÄ½±Àø
    AwardCount = 0    #(BYTE AwardCount)
    AwardItemList = list()    #(vector<tagMCFeastLoginDayAwardItem> AwardItemList)// ½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            temAwardItemList = tagMCFeastLoginDayAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.DayNum = 0
        self.AwardCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        for i in range(self.AwardCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.DayNum)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayNum:%d,
                                AwardCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.DayNum,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


class  tagMCFeastLoginInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    DayCount = 0    #(BYTE DayCount)// ×ܹ²¼¸Ìì
    DayAwardList = list()    #(vector<tagMCFeastLoginDayAward> DayAwardList)//µÇ¼Ìì½±ÀøÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x42
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.DayCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DayCount):
            temDayAwardList = tagMCFeastLoginDayAward()
            _pos = temDayAwardList.ReadData(_lpData, _pos)
            self.DayAwardList.append(temDayAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x42
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.DayCount = 0
        self.DayAwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.DayCount):
            length += self.DayAwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.DayCount)
        for i in range(self.DayCount):
            data = CommFunc.WriteString(data, self.DayAwardList[i].GetLength(), self.DayAwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                DayCount:%d,
                                DayAwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.DayCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastLoginInfo=tagMCFeastLoginInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastLoginInfo.Head.Cmd,m_NAtagMCFeastLoginInfo.Head.SubCmd))] = m_NAtagMCFeastLoginInfo


#------------------------------------------------------
# AA 39 ½ÚÈյǼ½±Àø»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCFeastLoginPlayerInfo

class  tagMCFeastLoginPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LoginState", c_int),    # ÊÇ·ñÒѵǼ£¬°´ÌìË÷Òý0´ú±íµÚ1Ìì¼Ç¼µ±ÌìÊÇ·ñÒѵǼ
                  ("LoginAward", c_int),    # ÊÇ·ñÒÑÁìÈ¡£¬°´ÌìË÷Òý0´ú±íµÚ1Ìì¼Ç¼µ±ÌìÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x39
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x39
        self.LoginState = 0
        self.LoginAward = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastLoginPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 39 ½ÚÈյǼ½±Àø»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCFeastLoginPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                LoginState:%d,
                                LoginAward:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LoginState,
                                self.LoginAward
                                )
        return DumpString


m_NAtagMCFeastLoginPlayerInfo=tagMCFeastLoginPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastLoginPlayerInfo.Cmd,m_NAtagMCFeastLoginPlayerInfo.SubCmd))] = m_NAtagMCFeastLoginPlayerInfo


#------------------------------------------------------
# AA 46 ½ÚÈÕÓÎÀú»î¶¯ÐÅÏ¢ #tagMCFeastTravelInfo

class  tagMCFeastTravelAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastTravelAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 46 ½ÚÈÕÓÎÀú»î¶¯ÐÅÏ¢ //tagMCFeastTravelInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCFeastTravelAward(Structure):
    AwardIndex = 0    #(BYTE AwardIndex)//ÓÎÀú½±ÀøË÷Òý
    NeedTravelPoint = 0    #(WORD NeedTravelPoint)//µ¥´ÎÁì½±ËùÐèÓÎÀúÖµ
    AwardCountMax = 0    #(WORD AwardCountMax)//×î´ó¿ÉÁìÈ¡´ÎÊý£¬0´ú±í²»ÏÞ
    AwardItemCount = 0    #(BYTE AwardItemCount)//½±ÀøÎïÆ·Êý
    AwardItemList = list()    #(vector<tagMCFeastTravelAwardItem> AwardItemList)//½±ÀøÎïÆ·Áбí
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedTravelPoint,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardCountMax,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItemList = tagMCFeastTravelAwardItem()
            _pos = temAwardItemList.ReadData(_lpData, _pos)
            self.AwardItemList.append(temAwardItemList)
        return _pos

    def Clear(self):
        self.AwardIndex = 0
        self.NeedTravelPoint = 0
        self.AwardCountMax = 0
        self.AwardItemCount = 0
        self.AwardItemList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 2
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.AwardIndex)
        data = CommFunc.WriteWORD(data, self.NeedTravelPoint)
        data = CommFunc.WriteWORD(data, self.AwardCountMax)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                AwardIndex:%d,
                                NeedTravelPoint:%d,
                                AwardCountMax:%d,
                                AwardItemCount:%d,
                                AwardItemList:%s
                                '''\
                                %(
                                self.AwardIndex,
                                self.NeedTravelPoint,
                                self.AwardCountMax,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCFeastTravelTask(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TravelTaskID", c_ubyte),    #ÓÎÀúÈÎÎñID
                  ("FinishNeedValue", c_ushort),    #µ¥´ÎÍê³ÉËùÐè½ø¶È
                  ("FinishTimeMax", c_ushort),    #×î´ó¿ÉÍê³É´ÎÊý£¬0´ú±í²»ÏÞ
                  ("AddTravelPoint", 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.TravelTaskID = 0
        self.FinishNeedValue = 0
        self.FinishTimeMax = 0
        self.AddTravelPoint = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastTravelTask)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 46 ½ÚÈÕÓÎÀú»î¶¯ÐÅÏ¢ //tagMCFeastTravelInfo:
                                TravelTaskID:%d,
                                FinishNeedValue:%d,
                                FinishTimeMax:%d,
                                AddTravelPoint:%d
                                '''\
                                %(
                                self.TravelTaskID,
                                self.FinishNeedValue,
                                self.FinishTimeMax,
                                self.AddTravelPoint
                                )
        return DumpString


class  tagMCFeastTravelInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µã¿ª£¬5µãÖØÖã»2-5µã¿ª£¬0µãÖØÖÃ
    TravelTaskCount = 0    #(BYTE TravelTaskCount)// ÓÎÀúÈÎÎñÊý
    TravelTaskList = list()    #(vector<tagMCFeastTravelTask> TravelTaskList)//ÓÎÀúÈÎÎñÐÅÏ¢Áбí
    TravelAwardCount = 0    #(BYTE TravelAwardCount)// ÓÎÀú½±ÀøÊý
    TravelAwardList = list()    #(vector<tagMCFeastTravelAward> TravelAwardList)//ÓÎÀú½±ÀøÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x46
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TravelTaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TravelTaskCount):
            temTravelTaskList = tagMCFeastTravelTask()
            _pos = temTravelTaskList.ReadData(_lpData, _pos)
            self.TravelTaskList.append(temTravelTaskList)
        self.TravelAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TravelAwardCount):
            temTravelAwardList = tagMCFeastTravelAward()
            _pos = temTravelAwardList.ReadData(_lpData, _pos)
            self.TravelAwardList.append(temTravelAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x46
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.ResetType = 0
        self.TravelTaskCount = 0
        self.TravelTaskList = list()
        self.TravelAwardCount = 0
        self.TravelAwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        for i in range(self.TravelTaskCount):
            length += self.TravelTaskList[i].GetLength()
        length += 1
        for i in range(self.TravelAwardCount):
            length += self.TravelAwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteBYTE(data, self.TravelTaskCount)
        for i in range(self.TravelTaskCount):
            data = CommFunc.WriteString(data, self.TravelTaskList[i].GetLength(), self.TravelTaskList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TravelAwardCount)
        for i in range(self.TravelAwardCount):
            data = CommFunc.WriteString(data, self.TravelAwardList[i].GetLength(), self.TravelAwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                ResetType:%d,
                                TravelTaskCount:%d,
                                TravelTaskList:%s,
                                TravelAwardCount:%d,
                                TravelAwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.ResetType,
                                self.TravelTaskCount,
                                "...",
                                self.TravelAwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastTravelInfo=tagMCFeastTravelInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastTravelInfo.Head.Cmd,m_NAtagMCFeastTravelInfo.Head.SubCmd))] = m_NAtagMCFeastTravelInfo


#------------------------------------------------------
# AA 47 ½ÚÈÕÓÎÀú»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCFeastTravelPlayerInfo

class  tagMCFeastTravelPlayerAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("AwardIndex", c_ubyte),    #ÓÎÀú½±ÀøË÷Òý
                  ("GetAwardCount", c_int),    #ÒÑÁìÈ¡´ÎÊý£»Ç°¶ËÅжÏÊÇ·ñ¿ÉÁìÈ¡: ×ÜÓÎÀúÖµ >=  (ÒÑÁìÈ¡´ÎÊý + 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.AwardIndex = 0
        self.GetAwardCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastTravelPlayerAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 47 ½ÚÈÕÓÎÀú»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCFeastTravelPlayerInfo:
                                AwardIndex:%d,
                                GetAwardCount:%d
                                '''\
                                %(
                                self.AwardIndex,
                                self.GetAwardCount
                                )
        return DumpString


class  tagMCFeastTravelPlayerTask(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TravelTaskID", c_ubyte),    #ÓÎÀúÈÎÎñID
                  ("TravelValue", c_int),    #µ±Ç°½ø¶ÈÖµ£¬Ò»Ö±ÀÛ¼Ó
                  ("FinishCount", c_ubyte),    #µ±Ç°ÒÑÍê³É´ÎÊý; Ç°¶Ë¼ÆËãδÍê³É´ÎÊýµÄ½ø¶ÈÖµ=max(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.TravelTaskID = 0
        self.TravelValue = 0
        self.FinishCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastTravelPlayerTask)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 47 ½ÚÈÕÓÎÀú»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCFeastTravelPlayerInfo:
                                TravelTaskID:%d,
                                TravelValue:%d,
                                FinishCount:%d
                                '''\
                                %(
                                self.TravelTaskID,
                                self.TravelValue,
                                self.FinishCount
                                )
        return DumpString


class  tagMCFeastTravelPlayerInfo(Structure):
    Head = tagHead()
    TravelPoint = 0    #(DWORD TravelPoint)//µ±Ç°×ÜÓÎÀúÖµ£¬Ò»Ö±ÀÛ¼Ó£¬²»»á¿ÛµÄ
    TravelPlayerTaskCount = 0    #(BYTE TravelPlayerTaskCount)// ÓÎÀúÈÎÎñÊý£¬²»Ò»¶¨ÓÐͬ²½£¬ÓÐͬ²½Êý¾ÝÔòÌæ»»¼´¿É
    TravelPlayerTaskList = list()    #(vector<tagMCFeastTravelPlayerTask> TravelPlayerTaskList)//ÓÎÀúÈÎÎñÐÅÏ¢Áбí
    TravelPlayerAwardCount = 0    #(BYTE TravelPlayerAwardCount)// ÓÎÀú½±ÀøÊý£¬²»Ò»¶¨ÓÐͬ²½£¬ÓÐͬ²½Êý¾ÝÔòÌæ»»¼´¿É
    TravelPlayerAwardList = list()    #(vector<tagMCFeastTravelPlayerAward> TravelPlayerAwardList)//ÓÎÀú½±ÀøÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x47
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.TravelPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TravelPlayerTaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TravelPlayerTaskCount):
            temTravelPlayerTaskList = tagMCFeastTravelPlayerTask()
            _pos = temTravelPlayerTaskList.ReadData(_lpData, _pos)
            self.TravelPlayerTaskList.append(temTravelPlayerTaskList)
        self.TravelPlayerAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TravelPlayerAwardCount):
            temTravelPlayerAwardList = tagMCFeastTravelPlayerAward()
            _pos = temTravelPlayerAwardList.ReadData(_lpData, _pos)
            self.TravelPlayerAwardList.append(temTravelPlayerAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x47
        self.TravelPoint = 0
        self.TravelPlayerTaskCount = 0
        self.TravelPlayerTaskList = list()
        self.TravelPlayerAwardCount = 0
        self.TravelPlayerAwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.TravelPlayerTaskCount):
            length += self.TravelPlayerTaskList[i].GetLength()
        length += 1
        for i in range(self.TravelPlayerAwardCount):
            length += self.TravelPlayerAwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.TravelPoint)
        data = CommFunc.WriteBYTE(data, self.TravelPlayerTaskCount)
        for i in range(self.TravelPlayerTaskCount):
            data = CommFunc.WriteString(data, self.TravelPlayerTaskList[i].GetLength(), self.TravelPlayerTaskList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TravelPlayerAwardCount)
        for i in range(self.TravelPlayerAwardCount):
            data = CommFunc.WriteString(data, self.TravelPlayerAwardList[i].GetLength(), self.TravelPlayerAwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                TravelPoint:%d,
                                TravelPlayerTaskCount:%d,
                                TravelPlayerTaskList:%s,
                                TravelPlayerAwardCount:%d,
                                TravelPlayerAwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.TravelPoint,
                                self.TravelPlayerTaskCount,
                                "...",
                                self.TravelPlayerAwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastTravelPlayerInfo=tagMCFeastTravelPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastTravelPlayerInfo.Head.Cmd,m_NAtagMCFeastTravelPlayerInfo.Head.SubCmd))] = m_NAtagMCFeastTravelPlayerInfo


#------------------------------------------------------
# AA 20 ½ÚÈÕѲÀñ»î¶¯ÐÅÏ¢ #tagMCFeastWeekPartyInfo

class  tagMCFeastWeekPartyItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NeedPoint", c_ushort),    # Áì½±ÐèÒª»ý·Ö
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.NeedPoint = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastWeekPartyItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 20 ½ÚÈÕѲÀñ»î¶¯ÐÅÏ¢ //tagMCFeastWeekPartyInfo:
                                NeedPoint:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.NeedPoint,
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind
                                )
        return DumpString


class  tagMCFeastWeekPartyAction(Structure):
    TemplateID = 0    #(DWORD TemplateID)// Ä£°åID
    ActionType = 0    #(WORD ActionType)// »î¶¯Àà±ð
    TotalTimes = 0    #(DWORD TotalTimes)// ¿ÉÍê³ÉµÄ×Ü´ÎÊý£¬0±íʾ²»ÏÞ´ÎÊý
    SingleTimes = 0    #(DWORD SingleTimes)// µ¥´ÎÁì½±ÐèÒªµÄ´ÎÊý
    Point = 0    #(DWORD Point)// µ¥´ÎÁì½±»ý·Ö
    Count = 0    #(BYTE Count)// ÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCFeastWeekPartyItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TemplateID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ActionType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TotalTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SingleTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Point,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temItemInfo = tagMCFeastWeekPartyItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        return _pos

    def Clear(self):
        self.TemplateID = 0
        self.ActionType = 0
        self.TotalTimes = 0
        self.SingleTimes = 0
        self.Point = 0
        self.Count = 0
        self.ItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 2
        length += 4
        length += 4
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.ItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.TemplateID)
        data = CommFunc.WriteWORD(data, self.ActionType)
        data = CommFunc.WriteDWORD(data, self.TotalTimes)
        data = CommFunc.WriteDWORD(data, self.SingleTimes)
        data = CommFunc.WriteDWORD(data, self.Point)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TemplateID:%d,
                                ActionType:%d,
                                TotalTimes:%d,
                                SingleTimes:%d,
                                Point:%d,
                                Count:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.TemplateID,
                                self.ActionType,
                                self.TotalTimes,
                                self.SingleTimes,
                                self.Point,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCFeastWeekPartyDayInfo(Structure):
    ActCnt = 0    #(BYTE ActCnt)// ÊýÁ¿
    TemplateList = list()    #(vector<WORD> TemplateList)// Ä£°åÁбí
    PCount = 0    #(BYTE PCount)// ÎïÆ·Êý
    PItemInfo = list()    #(vector<tagMCFeastWeekPartyItem> PItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ActCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActCnt):
            value,_pos=CommFunc.ReadWORD(_lpData,_pos)
            self.TemplateList.append(value)
        self.PCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PCount):
            temPItemInfo = tagMCFeastWeekPartyItem()
            _pos = temPItemInfo.ReadData(_lpData, _pos)
            self.PItemInfo.append(temPItemInfo)
        return _pos

    def Clear(self):
        self.ActCnt = 0
        self.TemplateList = list()
        self.PCount = 0
        self.PItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2 * self.ActCnt
        length += 1
        for i in range(self.PCount):
            length += self.PItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ActCnt)
        for i in range(self.ActCnt):
            data = CommFunc.WriteWORD(data, self.TemplateList[i])
        data = CommFunc.WriteBYTE(data, self.PCount)
        for i in range(self.PCount):
            data = CommFunc.WriteString(data, self.PItemInfo[i].GetLength(), self.PItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                ActCnt:%d,
                                TemplateList:%s,
                                PCount:%d,
                                PItemInfo:%s
                                '''\
                                %(
                                self.ActCnt,
                                "...",
                                self.PCount,
                                "..."
                                )
        return DumpString


class  tagMCFeastWeekPartyInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    DayCnt = 0    #(BYTE DayCnt)// ÌìÊý
    DayInfoList = list()    #(vector<tagMCFeastWeekPartyDayInfo> DayInfoList)// ÿÌìÄ£°å
    TCount = 0    #(BYTE TCount)// Ä£°åÊý
    ActionInfo = list()    #(vector<tagMCFeastWeekPartyAction> ActionInfo)// »î¶¯Ä£°åÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x20
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.DayCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DayCnt):
            temDayInfoList = tagMCFeastWeekPartyDayInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        self.TCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TCount):
            temActionInfo = tagMCFeastWeekPartyAction()
            _pos = temActionInfo.ReadData(_lpData, _pos)
            self.ActionInfo.append(temActionInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x20
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.DayCnt = 0
        self.DayInfoList = list()
        self.TCount = 0
        self.ActionInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.DayCnt):
            length += self.DayInfoList[i].GetLength()
        length += 1
        for i in range(self.TCount):
            length += self.ActionInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.DayCnt)
        for i in range(self.DayCnt):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TCount)
        for i in range(self.TCount):
            data = CommFunc.WriteString(data, self.ActionInfo[i].GetLength(), self.ActionInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                DayCnt:%d,
                                DayInfoList:%s,
                                TCount:%d,
                                ActionInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.DayCnt,
                                "...",
                                self.TCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastWeekPartyInfo=tagMCFeastWeekPartyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastWeekPartyInfo.Head.Cmd,m_NAtagMCFeastWeekPartyInfo.Head.SubCmd))] = m_NAtagMCFeastWeekPartyInfo


#------------------------------------------------------
# AA 21 ½ÚÈÕѲÀñÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCFeastWeekPartyPlayerInfo

class  tagMCFeastWeekPartyTaskInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TemplateID", c_ushort),    # Ä£°åID
                  ("CurTimes", c_int),    #ÒÑÍê³É´ÎÊý
                  ("GotTimes", 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.TemplateID = 0
        self.CurTimes = 0
        self.GotTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastWeekPartyTaskInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 21 ½ÚÈÕѲÀñÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCFeastWeekPartyPlayerInfo:
                                TemplateID:%d,
                                CurTimes:%d,
                                GotTimes:%d
                                '''\
                                %(
                                self.TemplateID,
                                self.CurTimes,
                                self.GotTimes
                                )
        return DumpString


class  tagMCFeastWeekPartyDayPlayerInfo(Structure):
    DayIndex = 0    #(DWORD DayIndex)//µÚXÌì
    Point = 0    #(DWORD Point)//»ý·Ö
    AwardRecord = 0    #(DWORD AwardRecord)//»ý·ÖÁì½±¼Ç¼
    ACount = 0    #(DWORD ACount)//ÈÎÎñÌõÄ¿Êý
    TaskList = list()    #(vector<tagMCFeastWeekPartyTaskInfo> TaskList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Point,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ACount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        for i in range(self.ACount):
            temTaskList = tagMCFeastWeekPartyTaskInfo()
            _pos = temTaskList.ReadData(_lpData, _pos)
            self.TaskList.append(temTaskList)
        return _pos

    def Clear(self):
        self.DayIndex = 0
        self.Point = 0
        self.AwardRecord = 0
        self.ACount = 0
        self.TaskList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 4
        length += 4
        for i in range(self.ACount):
            length += self.TaskList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.DayIndex)
        data = CommFunc.WriteDWORD(data, self.Point)
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteDWORD(data, self.ACount)
        for i in range(self.ACount):
            data = CommFunc.WriteString(data, self.TaskList[i].GetLength(), self.TaskList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayIndex:%d,
                                Point:%d,
                                AwardRecord:%d,
                                ACount:%d,
                                TaskList:%s
                                '''\
                                %(
                                self.DayIndex,
                                self.Point,
                                self.AwardRecord,
                                self.ACount,
                                "..."
                                )
        return DumpString


class  tagMCFeastWeekPartyPlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    DayInfoList = list()    #(vector<tagMCFeastWeekPartyDayPlayerInfo> DayInfoList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x21
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temDayInfoList = tagMCFeastWeekPartyDayPlayerInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x21
        self.Count = 0
        self.DayInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.DayInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                DayInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastWeekPartyPlayerInfo=tagMCFeastWeekPartyPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastWeekPartyPlayerInfo.Head.Cmd,m_NAtagMCFeastWeekPartyPlayerInfo.Head.SubCmd))] = m_NAtagMCFeastWeekPartyPlayerInfo


#------------------------------------------------------
# AA 43 ½ÚÈÕ×£¸£»î¶¯ÐÅÏ¢ #tagMCFeastWishInfo

class  tagMCFeastWishBottleItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("RecordIndex", c_ubyte),    #ÎïÆ·Ë÷Òý£¬ÓÃÓÚÑ¡Ôñ¼°¼Ç¼ÊÇ·ñÒÑÑ¡Ôñ
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.RecordIndex = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastWishBottleItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 43 ½ÚÈÕ×£¸£»î¶¯ÐÅÏ¢ //tagMCFeastWishInfo:
                                RecordIndex:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.RecordIndex,
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCFeastWishBottleInfo(Structure):
    BottleNum = 0    #(BYTE BottleNum)//Æ¿×Ó±àºÅ
    NeedWishValue = 0    #(WORD NeedWishValue)//µ¥´ÎÁì½±ËùÐè×£¸£Öµ
    ChooseTimeMax = 0    #(BYTE ChooseTimeMax)//×î´ó¿ÉÁì½±´ÎÊý
    ChoosePrizeCount = 0    #(BYTE ChoosePrizeCount)//¿ÉÑ¡Ôñ½±Àø¸öÊý
    ChoosePrizeList = list()    #(vector<tagMCFeastWishBottleItem> ChoosePrizeList)// Ñ¡Ôñ½±ÀøÎïÆ·ÁÐ±í£¬ÒÑÑ¡¹ýµÄÎÞ·¨ÔÙÑ¡
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.BottleNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.NeedWishValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ChooseTimeMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ChoosePrizeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ChoosePrizeCount):
            temChoosePrizeList = tagMCFeastWishBottleItem()
            _pos = temChoosePrizeList.ReadData(_lpData, _pos)
            self.ChoosePrizeList.append(temChoosePrizeList)
        return _pos

    def Clear(self):
        self.BottleNum = 0
        self.NeedWishValue = 0
        self.ChooseTimeMax = 0
        self.ChoosePrizeCount = 0
        self.ChoosePrizeList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        length += 1
        length += 1
        for i in range(self.ChoosePrizeCount):
            length += self.ChoosePrizeList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.BottleNum)
        data = CommFunc.WriteWORD(data, self.NeedWishValue)
        data = CommFunc.WriteBYTE(data, self.ChooseTimeMax)
        data = CommFunc.WriteBYTE(data, self.ChoosePrizeCount)
        for i in range(self.ChoosePrizeCount):
            data = CommFunc.WriteString(data, self.ChoosePrizeList[i].GetLength(), self.ChoosePrizeList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                BottleNum:%d,
                                NeedWishValue:%d,
                                ChooseTimeMax:%d,
                                ChoosePrizeCount:%d,
                                ChoosePrizeList:%s
                                '''\
                                %(
                                self.BottleNum,
                                self.NeedWishValue,
                                self.ChooseTimeMax,
                                self.ChoosePrizeCount,
                                "..."
                                )
        return DumpString


class  tagMCFeastWishInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µã¿ª£¬5µãÖØÖã»2-5µã¿ª£¬0µãÖØÖÃ
    WishPoolShowCount = 0    #(BYTE WishPoolShowCount)//×£¸£³ØչʾÎïÆ·Êý
    WishPoolShowItemList = list()    #(vector<DWORD> WishPoolShowItemList)//×£¸£³ØչʾÎïÆ·IDÁбí
    BottleCount = 0    #(BYTE BottleCount)// ×£¸£Æ¿¸öÊý
    BottleInfoList = list()    #(vector<tagMCFeastWishBottleInfo> BottleInfoList)// ×£¸£Æ¿ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x43
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WishPoolShowCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WishPoolShowCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.WishPoolShowItemList.append(value)
        self.BottleCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BottleCount):
            temBottleInfoList = tagMCFeastWishBottleInfo()
            _pos = temBottleInfoList.ReadData(_lpData, _pos)
            self.BottleInfoList.append(temBottleInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x43
        self.StartDate = ""
        self.EndtDate = ""
        self.LimitLV = 0
        self.ResetType = 0
        self.WishPoolShowCount = 0
        self.WishPoolShowItemList = list()
        self.BottleCount = 0
        self.BottleInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        length += 4 * self.WishPoolShowCount
        length += 1
        for i in range(self.BottleCount):
            length += self.BottleInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteBYTE(data, self.WishPoolShowCount)
        for i in range(self.WishPoolShowCount):
            data = CommFunc.WriteDWORD(data, self.WishPoolShowItemList[i])
        data = CommFunc.WriteBYTE(data, self.BottleCount)
        for i in range(self.BottleCount):
            data = CommFunc.WriteString(data, self.BottleInfoList[i].GetLength(), self.BottleInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                LimitLV:%d,
                                ResetType:%d,
                                WishPoolShowCount:%d,
                                WishPoolShowItemList:%s,
                                BottleCount:%d,
                                BottleInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.LimitLV,
                                self.ResetType,
                                self.WishPoolShowCount,
                                "...",
                                self.BottleCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastWishInfo=tagMCFeastWishInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastWishInfo.Head.Cmd,m_NAtagMCFeastWishInfo.Head.SubCmd))] = m_NAtagMCFeastWishInfo


#------------------------------------------------------
# AA 44 ½ÚÈÕ×£¸£»î¶¯Íæ¼ÒÐÅÏ¢ #tagMCFeastWishPlayerInfo

class  tagMCFeastWishPlayerBottle(Structure):
    _pack_ = 1
    _fields_ = [
                  ("BottleNum", c_ubyte),    #Æ¿×Ó±àºÅ
                  ("WishValue", c_ushort),    #µ±Ç°¿ÉÓÃ×£¸£Öµ
                  ("ChooseRecord", 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.BottleNum = 0
        self.WishValue = 0
        self.ChooseRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastWishPlayerBottle)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 44 ½ÚÈÕ×£¸£»î¶¯Íæ¼ÒÐÅÏ¢ //tagMCFeastWishPlayerInfo:
                                BottleNum:%d,
                                WishValue:%d,
                                ChooseRecord:%d
                                '''\
                                %(
                                self.BottleNum,
                                self.WishValue,
                                self.ChooseRecord
                                )
        return DumpString


class  tagMCFeastWishPlayerInfo(Structure):
    Head = tagHead()
    BottleCount = 0    #(BYTE BottleCount)// ×£¸£Æ¿¸öÊý
    PlayerBottleInfo = list()    #(vector<tagMCFeastWishPlayerBottle> PlayerBottleInfo)// ×£¸£Æ¿ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x44
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.BottleCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BottleCount):
            temPlayerBottleInfo = tagMCFeastWishPlayerBottle()
            _pos = temPlayerBottleInfo.ReadData(_lpData, _pos)
            self.PlayerBottleInfo.append(temPlayerBottleInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x44
        self.BottleCount = 0
        self.PlayerBottleInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.BottleCount):
            length += self.PlayerBottleInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.BottleCount)
        for i in range(self.BottleCount):
            data = CommFunc.WriteString(data, self.PlayerBottleInfo[i].GetLength(), self.PlayerBottleInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                BottleCount:%d,
                                PlayerBottleInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.BottleCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFeastWishPlayerInfo=tagMCFeastWishPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastWishPlayerInfo.Head.Cmd,m_NAtagMCFeastWishPlayerInfo.Head.SubCmd))] = m_NAtagMCFeastWishPlayerInfo


#------------------------------------------------------
# AA 45 ½ÚÈÕ×£¸£×£¸£½á¹û #tagMCFeastWishResult

class  tagMCFeastWishResult(Structure):
    Head = tagHead()
    AddWishValue = 0    #(WORD AddWishValue)// ±¾´ÎÔö¼ÓµÄ×£¸£Öµ
    WishResultLen = 0    #(WORD WishResultLen)
    WishResult = ""    #(String WishResult)//  »ñµÃÎïÆ·½á¹û[[ÎïÆ·ID,¸öÊý,ÊÇ·ñ°ó¶¨], ...]
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x45
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AddWishValue,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.WishResultLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.WishResult,_pos = CommFunc.ReadString(_lpData, _pos,self.WishResultLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x45
        self.AddWishValue = 0
        self.WishResultLen = 0
        self.WishResult = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        length += 2
        length += len(self.WishResult)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.AddWishValue)
        data = CommFunc.WriteWORD(data, self.WishResultLen)
        data = CommFunc.WriteString(data, self.WishResultLen, self.WishResult)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AddWishValue:%d,
                                WishResultLen:%d,
                                WishResult:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AddWishValue,
                                self.WishResultLen,
                                self.WishResult
                                )
        return DumpString


m_NAtagMCFeastWishResult=tagMCFeastWishResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastWishResult.Head.Cmd,m_NAtagMCFeastWishResult.Head.SubCmd))] = m_NAtagMCFeastWishResult


#------------------------------------------------------
# AA 02 Ê׳äÐÅÏ¢ #tagMCFirstGoldInfo

class  tagMCFirstGoldInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("FirstGoldRewardState", c_ubyte),    #Ê׳佱ÀøÁì½±¼Ç¼£¬°´Î»¼Ç¼Ê׳äµÚXÌìÊÇ·ñÒÑÁìÈ¡£¬µÚ1ÌìΪµÚ0Ë÷Òýλ
                  ("FirstGoldTry", c_ubyte),    #Ê׳äÊÔÓÃ״̬0-²»¿ÉÊÔÓà 1-¿ÉÊÔÓà 2-ÒÑÊÔÓÃ
                  ("FirstGoldServerDay", c_ushort),    #Ê׳äʱÊÇ¿ª·þµÚ¼¸Ì죬´Ó1¿ªÊ¼£¬0´ú±íδ¼Ç¼³äÖµ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x02
        self.FirstGoldRewardState = 0
        self.FirstGoldTry = 0
        self.FirstGoldServerDay = 0
        return

    def GetLength(self):
        return sizeof(tagMCFirstGoldInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 02 Ê׳äÐÅÏ¢ //tagMCFirstGoldInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                FirstGoldRewardState:%d,
                                FirstGoldTry:%d,
                                FirstGoldServerDay:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.FirstGoldRewardState,
                                self.FirstGoldTry,
                                self.FirstGoldServerDay
                                )
        return DumpString


m_NAtagMCFirstGoldInfo=tagMCFirstGoldInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFirstGoldInfo.Cmd,m_NAtagMCFirstGoldInfo.SubCmd))] = m_NAtagMCFirstGoldInfo


#------------------------------------------------------
# AA 08 Ê׳äÌáʾʣÓàʱ¼ä #tagMCFirstGoldTime

class  tagMCFirstGoldTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("FirstGoldRemainTime", c_int),    #Ê׳äÌáʾʣÓàʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x08
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x08
        self.FirstGoldRemainTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCFirstGoldTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 08 Ê׳äÌáʾʣÓàʱ¼ä //tagMCFirstGoldTime:
                                Cmd:%s,
                                SubCmd:%s,
                                FirstGoldRemainTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.FirstGoldRemainTime
                                )
        return DumpString


m_NAtagMCFirstGoldTime=tagMCFirstGoldTime()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFirstGoldTime.Cmd,m_NAtagMCFirstGoldTime.SubCmd))] = m_NAtagMCFirstGoldTime


#------------------------------------------------------
# AA 12 ÏÞʱÀñ°ü»î¶¯ÐÅÏ¢ #tagMCFlashGiftbagInfo

class  tagMCFlashGiftbagItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ("IsMainItem", c_ubyte),    #ÊÇ·ñ±êµÄÎï
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        self.IsMainItem = 0
        return

    def GetLength(self):
        return sizeof(tagMCFlashGiftbagItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 12 ÏÞʱÀñ°ü»î¶¯ÐÅÏ¢ //tagMCFlashGiftbagInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d,
                                IsMainItem:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind,
                                self.IsMainItem
                                )
        return DumpString


class  tagMCFlashGiftbag(Structure):
    GiftID = 0    #(DWORD GiftID)//Àñ°üID
    OrderInfoLen = 0    #(BYTE OrderInfoLen)
    OrderInfo = ""    #(String OrderInfo)//ÉÌÆ·±àºÅ
    BuyCountLimit = 0    #(BYTE BuyCountLimit)//ÏÞ¹ºÊý
    RMB = 0    #(DWORD RMB)//ËùÐèRMB£¬Ôª
    RMBOriginal = 0    #(DWORD RMBOriginal)//Ô­¼Û
    GiftItemCount = 0    #(BYTE GiftItemCount)// Àñ°üÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCFlashGiftbagItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.OrderInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderInfoLen)
        self.BuyCountLimit,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RMBOriginal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftItemCount):
            temItemInfo = tagMCFlashGiftbagItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        return _pos

    def Clear(self):
        self.GiftID = 0
        self.OrderInfoLen = 0
        self.OrderInfo = ""
        self.BuyCountLimit = 0
        self.RMB = 0
        self.RMBOriginal = 0
        self.GiftItemCount = 0
        self.ItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += len(self.OrderInfo)
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.GiftItemCount):
            length += self.ItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.GiftID)
        data = CommFunc.WriteBYTE(data, self.OrderInfoLen)
        data = CommFunc.WriteString(data, self.OrderInfoLen, self.OrderInfo)
        data = CommFunc.WriteBYTE(data, self.BuyCountLimit)
        data = CommFunc.WriteDWORD(data, self.RMB)
        data = CommFunc.WriteDWORD(data, self.RMBOriginal)
        data = CommFunc.WriteBYTE(data, self.GiftItemCount)
        for i in range(self.GiftItemCount):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GiftID:%d,
                                OrderInfoLen:%d,
                                OrderInfo:%s,
                                BuyCountLimit:%d,
                                RMB:%d,
                                RMBOriginal:%d,
                                GiftItemCount:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.GiftID,
                                self.OrderInfoLen,
                                self.OrderInfo,
                                self.BuyCountLimit,
                                self.RMB,
                                self.RMBOriginal,
                                self.GiftItemCount,
                                "..."
                                )
        return DumpString


class  tagMCFlashGiftbagType(Structure):
    GiftbagCount = 0    #(BYTE GiftbagCount)// Àñ°üÊý
    GiftbagInfo = list()    #(vector<tagMCFlashGiftbag> GiftbagInfo)// Àñ°üÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagInfo = tagMCFlashGiftbag()
            _pos = temGiftbagInfo.ReadData(_lpData, _pos)
            self.GiftbagInfo.append(temGiftbagInfo)
        return _pos

    def Clear(self):
        self.GiftbagCount = 0
        self.GiftbagInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagInfo[i].GetLength(), self.GiftbagInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GiftbagCount:%d,
                                GiftbagInfo:%s
                                '''\
                                %(
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


class  tagMCFlashGiftbagTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime
                                )
        return DumpString


class  tagMCFlashGiftbagInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    ActivityTimeCount = 0    #(BYTE ActivityTimeCount)
    ActivityTime = list()    #(vector<tagMCFlashGiftbagTime> ActivityTime)//»î¶¯Ê±¼ä
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    GiftbagTypeCount = 0    #(BYTE GiftbagTypeCount)// Àñ°üÀàÐÍÊý
    GiftbagTypeInfo = list()    #(vector<tagMCFlashGiftbagType> GiftbagTypeInfo)// Àñ°üÀàÐÍÐÅÏ¢, µ±Óжà¸öÇÒÓжà¸ö»î¶¯Ê±¼ä¶ÎʱÔòÿ¸öʱ¼ä¶Î¶ÔÓ¦Ò»¸öÀñ°üÀàÐÍ£»
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x12
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ActivityTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActivityTimeCount):
            temActivityTime = tagMCFlashGiftbagTime()
            _pos = temActivityTime.ReadData(_lpData, _pos)
            self.ActivityTime.append(temActivityTime)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GiftbagTypeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagTypeCount):
            temGiftbagTypeInfo = tagMCFlashGiftbagType()
            _pos = temGiftbagTypeInfo.ReadData(_lpData, _pos)
            self.GiftbagTypeInfo.append(temGiftbagTypeInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x12
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.ActivityTimeCount = 0
        self.ActivityTime = list()
        self.IsDayReset = 0
        self.LimitLV = 0
        self.GiftbagTypeCount = 0
        self.GiftbagTypeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.ActivityTimeCount):
            length += self.ActivityTime[i].GetLength()
        length += 1
        length += 2
        length += 1
        for i in range(self.GiftbagTypeCount):
            length += self.GiftbagTypeInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.ActivityTimeCount)
        for i in range(self.ActivityTimeCount):
            data = CommFunc.WriteString(data, self.ActivityTime[i].GetLength(), self.ActivityTime[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.GiftbagTypeCount)
        for i in range(self.GiftbagTypeCount):
            data = CommFunc.WriteString(data, self.GiftbagTypeInfo[i].GetLength(), self.GiftbagTypeInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                ActivityTimeCount:%d,
                                ActivityTime:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                GiftbagTypeCount:%d,
                                GiftbagTypeInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.ActivityTimeCount,
                                "...",
                                self.IsDayReset,
                                self.LimitLV,
                                self.GiftbagTypeCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFlashGiftbagInfo=tagMCFlashGiftbagInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFlashGiftbagInfo.Head.Cmd,m_NAtagMCFlashGiftbagInfo.Head.SubCmd))] = m_NAtagMCFlashGiftbagInfo


#------------------------------------------------------
# AA 13 ÏÞʱÀñ°üÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCFlashGiftbagPlayerInfo

class  tagMCFlashGiftbagBuyCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GiftbagID", c_int),    #Àñ°üID
                  ("BuyCount", 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.GiftbagID = 0
        self.BuyCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCFlashGiftbagBuyCount)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 13 ÏÞʱÀñ°üÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCFlashGiftbagPlayerInfo:
                                GiftbagID:%d,
                                BuyCount:%d
                                '''\
                                %(
                                self.GiftbagID,
                                self.BuyCount
                                )
        return DumpString


class  tagMCFlashGiftbagPlayerInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    Count = 0    #(BYTE Count)
    BuyCountList = list()    #(vector<tagMCFlashGiftbagBuyCount> BuyCountList)//Àñ°ü¹ºÂò´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBuyCountList = tagMCFlashGiftbagBuyCount()
            _pos = temBuyCountList.ReadData(_lpData, _pos)
            self.BuyCountList.append(temBuyCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x13
        self.ActNum = 0
        self.Count = 0
        self.BuyCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.Count):
            length += self.BuyCountList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BuyCountList[i].GetLength(), self.BuyCountList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                Count:%d,
                                BuyCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFlashGiftbagPlayerInfo=tagMCFlashGiftbagPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFlashGiftbagPlayerInfo.Head.Cmd,m_NAtagMCFlashGiftbagPlayerInfo.Head.SubCmd))] = m_NAtagMCFlashGiftbagPlayerInfo


#------------------------------------------------------
# AA 18 ÏÞʱÇÀ¹º»î¶¯Íæ¼ÒÔ¤Ô¼ÐÅÏ¢ #tagMCFlashSaleAppointmentInfo

class  tagMCFlashSaleAppointmentState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GoodsMark", c_int),    # ÉÌÆ·±êʶ
                  ("State", c_ubyte),    # ÊÇ·ñÔ¤Ô¼
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.GoodsMark = 0
        self.State = 0
        return

    def GetLength(self):
        return sizeof(tagMCFlashSaleAppointmentState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 18 ÏÞʱÇÀ¹º»î¶¯Íæ¼ÒÔ¤Ô¼ÐÅÏ¢ //tagMCFlashSaleAppointmentInfo:
                                GoodsMark:%d,
                                State:%d
                                '''\
                                %(
                                self.GoodsMark,
                                self.State
                                )
        return DumpString


class  tagMCFlashSaleAppointmentInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    IsAll = 0    #(BYTE IsAll)// ÊÇ·ñÈ«²¿
    GoodsCount = 0    #(WORD GoodsCount)// ÉÌÆ·Êý
    GoodsList = list()    #(vector<tagMCFlashSaleAppointmentState> GoodsList)// Ô¤Ô¼µÄÉÌÆ·
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x18
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsAll,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GoodsCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.GoodsCount):
            temGoodsList = tagMCFlashSaleAppointmentState()
            _pos = temGoodsList.ReadData(_lpData, _pos)
            self.GoodsList.append(temGoodsList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x18
        self.ActNum = 0
        self.IsAll = 0
        self.GoodsCount = 0
        self.GoodsList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 2
        for i in range(self.GoodsCount):
            length += self.GoodsList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteBYTE(data, self.IsAll)
        data = CommFunc.WriteWORD(data, self.GoodsCount)
        for i in range(self.GoodsCount):
            data = CommFunc.WriteString(data, self.GoodsList[i].GetLength(), self.GoodsList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                IsAll:%d,
                                GoodsCount:%d,
                                GoodsList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.IsAll,
                                self.GoodsCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFlashSaleAppointmentInfo=tagMCFlashSaleAppointmentInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFlashSaleAppointmentInfo.Head.Cmd,m_NAtagMCFlashSaleAppointmentInfo.Head.SubCmd))] = m_NAtagMCFlashSaleAppointmentInfo


#------------------------------------------------------
# AA 17 ÏÞʱÇÀ¹º»î¶¯ÐÅÏ¢ #tagMCFlashSaleInfo

class  tagMCFlashSaleGiftbag(Structure):
    _pack_ = 1
    _fields_ = [
                  ("GiftID", c_int),    #É̳DZíµÄÎïÆ·ID
                  ("BuyCountLimit", c_ubyte),    #ÏÞ¹ºÊý
                  ("ServerBuyCountLimit", c_ushort),    #È«·þÏÞ¹ºÊý
                  ("MoneyType", c_ubyte),    #ÏûºÄ»õ±ÒÀàÐÍ
                  ("MoneyNumber", c_int),    #ÏûºÄ»õ±ÒÊýÁ¿
                  ("MoneyOriginal", c_int),    #Ô­¼Û
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.GiftID = 0
        self.BuyCountLimit = 0
        self.ServerBuyCountLimit = 0
        self.MoneyType = 0
        self.MoneyNumber = 0
        self.MoneyOriginal = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCFlashSaleGiftbag)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 17 ÏÞʱÇÀ¹º»î¶¯ÐÅÏ¢ //tagMCFlashSaleInfo:
                                GiftID:%d,
                                BuyCountLimit:%d,
                                ServerBuyCountLimit:%d,
                                MoneyType:%d,
                                MoneyNumber:%d,
                                MoneyOriginal:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.GiftID,
                                self.BuyCountLimit,
                                self.ServerBuyCountLimit,
                                self.MoneyType,
                                self.MoneyNumber,
                                self.MoneyOriginal,
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCFlashSaleShop(Structure):
    DayIndex = 0    #(BYTE DayIndex)// »î¶¯µÚ¼¸Ìì
    TimeIndex = 0    #(BYTE TimeIndex)// µÚ¼¸¸öʱ¼ä¶Î
    GiftbagCount = 0    #(BYTE GiftbagCount)// É̵êÀñ°üÊý
    GiftbagInfo = list()    #(vector<tagMCFlashSaleGiftbag> GiftbagInfo)// Àñ°üÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TimeIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagInfo = tagMCFlashSaleGiftbag()
            _pos = temGiftbagInfo.ReadData(_lpData, _pos)
            self.GiftbagInfo.append(temGiftbagInfo)
        return _pos

    def Clear(self):
        self.DayIndex = 0
        self.TimeIndex = 0
        self.GiftbagCount = 0
        self.GiftbagInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.DayIndex)
        data = CommFunc.WriteBYTE(data, self.TimeIndex)
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagInfo[i].GetLength(), self.GiftbagInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayIndex:%d,
                                TimeIndex:%d,
                                GiftbagCount:%d,
                                GiftbagInfo:%s
                                '''\
                                %(
                                self.DayIndex,
                                self.TimeIndex,
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


class  tagMCFlashSaleTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime
                                )
        return DumpString


class  tagMCFlashSaleInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    ActivityTimeCount = 0    #(BYTE ActivityTimeCount)
    ActivityTime = list()    #(vector<tagMCFlashSaleTime> ActivityTime)//»î¶¯Ê±¼ä
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ShopCount = 0    #(BYTE ShopCount)// É̵êÊý
    ShopInfo = list()    #(vector<tagMCFlashSaleShop> ShopInfo)// É̵êÐÅÏ¢, µ±Óжà¸öÉ̵êÇÒÓжà¸ö»î¶¯Ê±¼ä¶ÎʱÔòÿ¸öʱ¼ä¶Î¶ÔÓ¦Ò»¸öÉ̵ꣻ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ActivityTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActivityTimeCount):
            temActivityTime = tagMCFlashSaleTime()
            _pos = temActivityTime.ReadData(_lpData, _pos)
            self.ActivityTime.append(temActivityTime)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ShopCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ShopCount):
            temShopInfo = tagMCFlashSaleShop()
            _pos = temShopInfo.ReadData(_lpData, _pos)
            self.ShopInfo.append(temShopInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x17
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.ActivityTimeCount = 0
        self.ActivityTime = list()
        self.IsDayReset = 0
        self.LimitLV = 0
        self.ShopCount = 0
        self.ShopInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.ActivityTimeCount):
            length += self.ActivityTime[i].GetLength()
        length += 1
        length += 2
        length += 1
        for i in range(self.ShopCount):
            length += self.ShopInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.ActivityTimeCount)
        for i in range(self.ActivityTimeCount):
            data = CommFunc.WriteString(data, self.ActivityTime[i].GetLength(), self.ActivityTime[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ShopCount)
        for i in range(self.ShopCount):
            data = CommFunc.WriteString(data, self.ShopInfo[i].GetLength(), self.ShopInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                ActivityTimeCount:%d,
                                ActivityTime:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                ShopCount:%d,
                                ShopInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.ActivityTimeCount,
                                "...",
                                self.IsDayReset,
                                self.LimitLV,
                                self.ShopCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFlashSaleInfo=tagMCFlashSaleInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFlashSaleInfo.Head.Cmd,m_NAtagMCFlashSaleInfo.Head.SubCmd))] = m_NAtagMCFlashSaleInfo


#------------------------------------------------------
# AA 1F ÐÒÔ˼ø±¦»î¶¯ÐÅÏ¢ #tagMCLuckyTreasureInfo

class  tagMCLuckyTreasureItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCLuckyTreasureItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1F ÐÒÔ˼ø±¦»î¶¯ÐÅÏ¢ //tagMCLuckyTreasureInfo:
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind
                                )
        return DumpString


class  tagMCLuckyTreasureInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    LuckyPoint = 0    #(WORD LuckyPoint)// ×ÜÐÒÔËÖµ
    Count = 0    #(WORD Count)// ÎïÆ·Êý
    ItemList = list()    #(vector<tagMCLuckyTreasureItem> ItemList)// Ëæ»ú¿âÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1F
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LuckyPoint,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temItemList = tagMCLuckyTreasureItem()
            _pos = temItemList.ReadData(_lpData, _pos)
            self.ItemList.append(temItemList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x1F
        self.StartDate = ""
        self.EndtDate = ""
        self.ResetType = 0
        self.LimitLV = 0
        self.LuckyPoint = 0
        self.Count = 0
        self.ItemList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 1
        length += 2
        length += 2
        length += 2
        for i in range(self.Count):
            length += self.ItemList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteWORD(data, self.LuckyPoint)
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ItemList[i].GetLength(), self.ItemList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                ResetType:%d,
                                LimitLV:%d,
                                LuckyPoint:%d,
                                Count:%d,
                                ItemList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.ResetType,
                                self.LimitLV,
                                self.LuckyPoint,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCLuckyTreasureInfo=tagMCLuckyTreasureInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLuckyTreasureInfo.Head.Cmd,m_NAtagMCLuckyTreasureInfo.Head.SubCmd))] = m_NAtagMCLuckyTreasureInfo


#------------------------------------------------------
# AA 1E ÐÒÔ˼ø±¦½á¹ûÐÅÏ¢ #tagMCLuckyTreasureResultInfo

class  tagMCLuckyTreasureResultInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("LuckyPoint", c_ushort),    # µ±Ç°ÐÒÔ˵ã
                  ("HasFree", c_ubyte),    # ÊÇ·ñÃâ·Ñ¹ý
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    #ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x1E
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x1E
        self.LuckyPoint = 0
        self.HasFree = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCLuckyTreasureResultInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1E ÐÒÔ˼ø±¦½á¹ûÐÅÏ¢ //tagMCLuckyTreasureResultInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                LuckyPoint:%d,
                                HasFree:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.LuckyPoint,
                                self.HasFree,
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind
                                )
        return DumpString


m_NAtagMCLuckyTreasureResultInfo=tagMCLuckyTreasureResultInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLuckyTreasureResultInfo.Cmd,m_NAtagMCLuckyTreasureResultInfo.SubCmd))] = m_NAtagMCLuckyTreasureResultInfo


#------------------------------------------------------
# AA 23 ÐÂÏɽçÊ¢µäÈ«ÃñÀ´àËÍæ¼ÒÐÅÏ¢ #tagMCNewAllPeoplePartyInfo

class  tagMCNewAllPeoplePartyCount(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ActID", c_int),    #»î¶¯ID
                  ("CurTimes", 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.ActID = 0
        self.CurTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCNewAllPeoplePartyCount)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 23 ÐÂÏɽçÊ¢µäÈ«ÃñÀ´àËÍæ¼ÒÐÅÏ¢ //tagMCNewAllPeoplePartyInfo:
                                ActID:%d,
                                CurTimes:%d
                                '''\
                                %(
                                self.ActID,
                                self.CurTimes
                                )
        return DumpString


class  tagMCNewAllPeoplePartyInfo(Structure):
    Head = tagHead()
    CurPoint = 0    #(DWORD CurPoint)//µ±Ç°×ܵãÊý
    AwardRecord = 0    #(DWORD AwardRecord)//Áì½±¼Ç¼ °´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡
    Count = 0    #(BYTE Count)
    BuyCountList = list()    #(vector<tagMCNewAllPeoplePartyCount> BuyCountList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x23
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CurPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temBuyCountList = tagMCNewAllPeoplePartyCount()
            _pos = temBuyCountList.ReadData(_lpData, _pos)
            self.BuyCountList.append(temBuyCountList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x23
        self.CurPoint = 0
        self.AwardRecord = 0
        self.Count = 0
        self.BuyCountList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.BuyCountList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.CurPoint)
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.BuyCountList[i].GetLength(), self.BuyCountList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CurPoint:%d,
                                AwardRecord:%d,
                                Count:%d,
                                BuyCountList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CurPoint,
                                self.AwardRecord,
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCNewAllPeoplePartyInfo=tagMCNewAllPeoplePartyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNewAllPeoplePartyInfo.Head.Cmd,m_NAtagMCNewAllPeoplePartyInfo.Head.SubCmd))] = m_NAtagMCNewAllPeoplePartyInfo


#------------------------------------------------------
# AA 22 ÐÂÏɽçÊ¢µä³äÖµ´óÀñ #tagMCNewXJSDRecharge

class  tagMCNewXJSDRecharge(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("State", c_ubyte),    #0-²»¿ÉÁì 1-¿ÉÁì 2-ÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x22
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x22
        self.State = 0
        return

    def GetLength(self):
        return sizeof(tagMCNewXJSDRecharge)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 22 ÐÂÏɽçÊ¢µä³äÖµ´óÀñ //tagMCNewXJSDRecharge:
                                Cmd:%s,
                                SubCmd:%s,
                                State:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.State
                                )
        return DumpString


m_NAtagMCNewXJSDRecharge=tagMCNewXJSDRecharge()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNewXJSDRecharge.Cmd,m_NAtagMCNewXJSDRecharge.SubCmd))] = m_NAtagMCNewXJSDRecharge


#------------------------------------------------------
# AA 04 ´´½ÇÔÚÏß³äÖµÌØ»ÝÐÅÏ¢ #tagMCOnlineRechargeTH

class  tagMCOnlineRechargeTH(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AwardState", c_ubyte),    #ÊÇ·ñÒÑÁìÈ¡½±Àø
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x04
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x04
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCOnlineRechargeTH)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 04 ´´½ÇÔÚÏß³äÖµÌØ»ÝÐÅÏ¢ //tagMCOnlineRechargeTH:
                                Cmd:%s,
                                SubCmd:%s,
                                AwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AwardState
                                )
        return DumpString


m_NAtagMCOnlineRechargeTH=tagMCOnlineRechargeTH()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOnlineRechargeTH.Cmd,m_NAtagMCOnlineRechargeTH.SubCmd))] = m_NAtagMCOnlineRechargeTH


#------------------------------------------------------
# AA 28 ³äÖµ·µÀûÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCRechargePrizePlayerInfo

class  tagMCRechargePrizeInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("CTGID", c_ushort),    # ¶ÔÓ¦³äÖµ±í³äÖµID
                  ("PrizeCount", c_ubyte),    # ÒÑ·µÀû´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.CTGID = 0
        self.PrizeCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCRechargePrizeInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 28 ³äÖµ·µÀûÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCRechargePrizePlayerInfo:
                                CTGID:%d,
                                PrizeCount:%d
                                '''\
                                %(
                                self.CTGID,
                                self.PrizeCount
                                )
        return DumpString


class  tagMCRechargePrizePlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    PlayerInfoList = list()    #(vector<tagMCRechargePrizeInfo> PlayerInfoList)//Íæ¼Ò·µÀûÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x28
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temPlayerInfoList = tagMCRechargePrizeInfo()
            _pos = temPlayerInfoList.ReadData(_lpData, _pos)
            self.PlayerInfoList.append(temPlayerInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x28
        self.Count = 0
        self.PlayerInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            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.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.PlayerInfoList[i].GetLength(), self.PlayerInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                PlayerInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCRechargePrizePlayerInfo=tagMCRechargePrizePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRechargePrizePlayerInfo.Head.Cmd,m_NAtagMCRechargePrizePlayerInfo.Head.SubCmd))] = m_NAtagMCRechargePrizePlayerInfo


#------------------------------------------------------
# AA 30 ÀۼƳäÖµ·µÀûÏÉÓñÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCRechargeRebateGoldPlayerInfo

class  tagMCRechargeRebateGoldPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("RechargeRMBTotal", c_int),    # »î¶¯ÒÑÀۼƳäÖµRMB
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x30
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x30
        self.RechargeRMBTotal = 0
        return

    def GetLength(self):
        return sizeof(tagMCRechargeRebateGoldPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 30 ÀۼƳäÖµ·µÀûÏÉÓñÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCRechargeRebateGoldPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                RechargeRMBTotal:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.RechargeRMBTotal
                                )
        return DumpString


m_NAtagMCRechargeRebateGoldPlayerInfo=tagMCRechargeRebateGoldPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRechargeRebateGoldPlayerInfo.Cmd,m_NAtagMCRechargeRebateGoldPlayerInfo.SubCmd))] = m_NAtagMCRechargeRebateGoldPlayerInfo


#------------------------------------------------------
# AA 11 ÏÞʱÌػݻÐÅÏ¢ #tagMCSpringSaleInfo

class  tagMCSpringSaleItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ("IsMainItem", c_ubyte),    #ÊÇ·ñ±êµÄÎï
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        self.IsMainItem = 0
        return

    def GetLength(self):
        return sizeof(tagMCSpringSaleItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 11 ÏÞʱÌػݻÐÅÏ¢ //tagMCSpringSaleInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d,
                                IsMainItem:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind,
                                self.IsMainItem
                                )
        return DumpString


class  tagMCSpringSaleGiftbag(Structure):
    GiftID = 0    #(DWORD GiftID)//É̳DZíµÄÎïÆ·ID
    BuyCountLimit = 0    #(BYTE BuyCountLimit)//ÏÞ¹ºÊý
    MoneyType = 0    #(BYTE MoneyType)//ÏûºÄ»õ±ÒÀàÐÍ
    MoneyNumber = 0    #(DWORD MoneyNumber)//ÏûºÄ»õ±ÒÊýÁ¿
    MoneyOriginal = 0    #(DWORD MoneyOriginal)//Ô­¼Û
    GiftItemCount = 0    #(BYTE GiftItemCount)// Àñ°üÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCSpringSaleItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BuyCountLimit,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.MoneyNumber,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MoneyOriginal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.GiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftItemCount):
            temItemInfo = tagMCSpringSaleItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        return _pos

    def Clear(self):
        self.GiftID = 0
        self.BuyCountLimit = 0
        self.MoneyType = 0
        self.MoneyNumber = 0
        self.MoneyOriginal = 0
        self.GiftItemCount = 0
        self.ItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += 1
        length += 4
        length += 4
        length += 1
        for i in range(self.GiftItemCount):
            length += self.ItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.GiftID)
        data = CommFunc.WriteBYTE(data, self.BuyCountLimit)
        data = CommFunc.WriteBYTE(data, self.MoneyType)
        data = CommFunc.WriteDWORD(data, self.MoneyNumber)
        data = CommFunc.WriteDWORD(data, self.MoneyOriginal)
        data = CommFunc.WriteBYTE(data, self.GiftItemCount)
        for i in range(self.GiftItemCount):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GiftID:%d,
                                BuyCountLimit:%d,
                                MoneyType:%d,
                                MoneyNumber:%d,
                                MoneyOriginal:%d,
                                GiftItemCount:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.GiftID,
                                self.BuyCountLimit,
                                self.MoneyType,
                                self.MoneyNumber,
                                self.MoneyOriginal,
                                self.GiftItemCount,
                                "..."
                                )
        return DumpString


class  tagMCSpringSaleShop(Structure):
    GiftbagCount = 0    #(BYTE GiftbagCount)// É̵êÀñ°üÊý
    GiftbagInfo = list()    #(vector<tagMCSpringSaleGiftbag> GiftbagInfo)// Àñ°üÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.GiftbagCount):
            temGiftbagInfo = tagMCSpringSaleGiftbag()
            _pos = temGiftbagInfo.ReadData(_lpData, _pos)
            self.GiftbagInfo.append(temGiftbagInfo)
        return _pos

    def Clear(self):
        self.GiftbagCount = 0
        self.GiftbagInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        for i in range(self.GiftbagCount):
            length += self.GiftbagInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.GiftbagCount)
        for i in range(self.GiftbagCount):
            data = CommFunc.WriteString(data, self.GiftbagInfo[i].GetLength(), self.GiftbagInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                GiftbagCount:%d,
                                GiftbagInfo:%s
                                '''\
                                %(
                                self.GiftbagCount,
                                "..."
                                )
        return DumpString


class  tagMCSpringSaleTime(Structure):
    StartTime = ""    #(char StartTime[5])// ¿ªÊ¼Ê±¼ä H:M
    EndtTime = ""    #(char EndtTime[5])// ½áÊøʱ¼ä H:M
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
        return _pos

    def Clear(self):
        self.StartTime = ""
        self.EndtTime = ""
        return

    def GetLength(self):
        length = 0
        length += 5
        length += 5

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 5, self.StartTime)
        data = CommFunc.WriteString(data, 5, self.EndtTime)
        return data

    def OutputString(self):
        DumpString = '''
                                StartTime:%s,
                                EndtTime:%s
                                '''\
                                %(
                                self.StartTime,
                                self.EndtTime
                                )
        return DumpString


class  tagMCSpringSaleInfo(Structure):
    Head = tagHead()
    ActNum = 0    #(BYTE ActNum)//»î¶¯±àºÅ
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    ActivityTimeCount = 0    #(BYTE ActivityTimeCount)
    ActivityTime = list()    #(vector<tagMCSpringSaleTime> ActivityTime)//»î¶¯Ê±¼ä
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    ShopCount = 0    #(BYTE ShopCount)// É̵êÊý
    ShopInfo = list()    #(vector<tagMCSpringSaleShop> ShopInfo)// É̵êÐÅÏ¢, µ±Óжà¸öÉ̵êÇÒÓжà¸ö»î¶¯Ê±¼ä¶ÎʱÔòÿ¸öʱ¼ä¶Î¶ÔÓ¦Ò»¸öÉ̵ꣻ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x11
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ActivityTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActivityTimeCount):
            temActivityTime = tagMCSpringSaleTime()
            _pos = temActivityTime.ReadData(_lpData, _pos)
            self.ActivityTime.append(temActivityTime)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ShopCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ShopCount):
            temShopInfo = tagMCSpringSaleShop()
            _pos = temShopInfo.ReadData(_lpData, _pos)
            self.ShopInfo.append(temShopInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x11
        self.ActNum = 0
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.ActivityTimeCount = 0
        self.ActivityTime = list()
        self.IsDayReset = 0
        self.LimitLV = 0
        self.ShopCount = 0
        self.ShopInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 10
        length += 10
        length += 2
        length += 1
        for i in range(self.ActivityTimeCount):
            length += self.ActivityTime[i].GetLength()
        length += 1
        length += 2
        length += 1
        for i in range(self.ShopCount):
            length += self.ShopInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ActNum)
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.ActivityTimeCount)
        for i in range(self.ActivityTimeCount):
            data = CommFunc.WriteString(data, self.ActivityTime[i].GetLength(), self.ActivityTime[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.ShopCount)
        for i in range(self.ShopCount):
            data = CommFunc.WriteString(data, self.ShopInfo[i].GetLength(), self.ShopInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ActNum:%d,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                ActivityTimeCount:%d,
                                ActivityTime:%s,
                                IsDayReset:%d,
                                LimitLV:%d,
                                ShopCount:%d,
                                ShopInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ActNum,
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.ActivityTimeCount,
                                "...",
                                self.IsDayReset,
                                self.LimitLV,
                                self.ShopCount,
                                "..."
                                )
        return DumpString


m_NAtagMCSpringSaleInfo=tagMCSpringSaleInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSpringSaleInfo.Head.Cmd,m_NAtagMCSpringSaleInfo.Head.SubCmd))] = m_NAtagMCSpringSaleInfo


#------------------------------------------------------
# AA 16 ֪ͨ³¬ÖµÀñ°üÐÅÏ¢ #tagMCSuperGiftInfo

class  tagMCSuperGiftInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("StartTime", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x16
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x16
        self.StartTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCSuperGiftInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 16 ֪ͨ³¬ÖµÀñ°üÐÅÏ¢ //tagMCSuperGiftInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                StartTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.StartTime
                                )
        return DumpString


m_NAtagMCSuperGiftInfo=tagMCSuperGiftInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuperGiftInfo.Cmd,m_NAtagMCSuperGiftInfo.SubCmd))] = m_NAtagMCSuperGiftInfo


#------------------------------------------------------
#AA 01 ÀۼƵǽÌìÊýÐÅÏ¢ #tagMCTotalLoginDayCntInfo

class  tagMCTotalLoginDayCntInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DayCnt", c_ushort),    #ÀۼƵǽÌìÊý
                  ("AwardInfo", c_ushort),    #µÇ½ÁìÈ¡Çé¿ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x01
        self.DayCnt = 0
        self.AwardInfo = 0
        return

    def GetLength(self):
        return sizeof(tagMCTotalLoginDayCntInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//AA 01 ÀۼƵǽÌìÊýÐÅÏ¢ //tagMCTotalLoginDayCntInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                DayCnt:%d,
                                AwardInfo:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DayCnt,
                                self.AwardInfo
                                )
        return DumpString


m_NAtagMCTotalLoginDayCntInfo=tagMCTotalLoginDayCntInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTotalLoginDayCntInfo.Cmd,m_NAtagMCTotalLoginDayCntInfo.SubCmd))] = m_NAtagMCTotalLoginDayCntInfo


#------------------------------------------------------
# AA 1C ÀۼƳäÖµÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCTotalRechargePlayerInfo

class  tagMCTotalRechargePlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ActNum", c_ubyte),    #»î¶¯±àºÅ´Ó1¿ªÊ¼£¬Ä¿Ç°Ö§³ÖÁ½¸öÀÛ³ä»î¶¯Í¬Ê±´æÔÚÇÒÏ໥¶ÀÁ¢ 1»ò2
                  ("GoldTotal", c_int),    #±¾´Î»î¶¯ÒÑÀۼƳäÖµÏÉÓñÊý
                  ("AwardRecord", c_int),    #½±ÀøÁì½±¼Ç¼£¬°´½±ÀøË÷Òý¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x1C
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x1C
        self.ActNum = 0
        self.GoldTotal = 0
        self.AwardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCTotalRechargePlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 1C ÀۼƳäÖµÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCTotalRechargePlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ActNum:%d,
                                GoldTotal:%d,
                                AwardRecord:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ActNum,
                                self.GoldTotal,
                                self.AwardRecord
                                )
        return DumpString


m_NAtagMCTotalRechargePlayerInfo=tagMCTotalRechargePlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTotalRechargePlayerInfo.Cmd,m_NAtagMCTotalRechargePlayerInfo.SubCmd))] = m_NAtagMCTotalRechargePlayerInfo


#------------------------------------------------------
# AA 0A ÖÜ¿ñ»¶»î¶¯ÐÅÏ¢ #tagMCWeekPartyInfo

class  tagMCWeekPartyItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NeedPoint", c_ushort),    # Áì½±ÐèÒª»ý·Ö
                  ("ItemID", c_int),    # ÎïÆ·ID
                  ("ItemCnt", c_ushort),    # ÎïÆ·ÊýÁ¿
                  ("IsBind", c_ubyte),    # ÊÇ·ñ°ó¶¨
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.NeedPoint = 0
        self.ItemID = 0
        self.ItemCnt = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCWeekPartyItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 0A ÖÜ¿ñ»¶»î¶¯ÐÅÏ¢ //tagMCWeekPartyInfo:
                                NeedPoint:%d,
                                ItemID:%d,
                                ItemCnt:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.NeedPoint,
                                self.ItemID,
                                self.ItemCnt,
                                self.IsBind
                                )
        return DumpString


class  tagMCWeekPartyAction(Structure):
    TemplateID = 0    #(DWORD TemplateID)// Ä£°åID
    ActionType = 0    #(WORD ActionType)// »î¶¯Àà±ð
    TotalTimes = 0    #(DWORD TotalTimes)// ¿ÉÍê³ÉµÄ×Ü´ÎÊý£¬0±íʾ²»ÏÞ´ÎÊý
    SingleTimes = 0    #(DWORD SingleTimes)// µ¥´ÎÁì½±ÐèÒªµÄ´ÎÊý
    Point = 0    #(DWORD Point)// µ¥´ÎÁì½±»ý·Ö
    Count = 0    #(BYTE Count)// ÎïÆ·Êý
    ItemInfo = list()    #(vector<tagMCWeekPartyItem> ItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TemplateID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ActionType,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TotalTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SingleTimes,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Point,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temItemInfo = tagMCWeekPartyItem()
            _pos = temItemInfo.ReadData(_lpData, _pos)
            self.ItemInfo.append(temItemInfo)
        return _pos

    def Clear(self):
        self.TemplateID = 0
        self.ActionType = 0
        self.TotalTimes = 0
        self.SingleTimes = 0
        self.Point = 0
        self.Count = 0
        self.ItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 2
        length += 4
        length += 4
        length += 4
        length += 1
        for i in range(self.Count):
            length += self.ItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.TemplateID)
        data = CommFunc.WriteWORD(data, self.ActionType)
        data = CommFunc.WriteDWORD(data, self.TotalTimes)
        data = CommFunc.WriteDWORD(data, self.SingleTimes)
        data = CommFunc.WriteDWORD(data, self.Point)
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TemplateID:%d,
                                ActionType:%d,
                                TotalTimes:%d,
                                SingleTimes:%d,
                                Point:%d,
                                Count:%d,
                                ItemInfo:%s
                                '''\
                                %(
                                self.TemplateID,
                                self.ActionType,
                                self.TotalTimes,
                                self.SingleTimes,
                                self.Point,
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCWeekPartyDayInfo(Structure):
    ActCnt = 0    #(BYTE ActCnt)// ÊýÁ¿
    TemplateList = list()    #(vector<WORD> TemplateList)// Ä£°åÁбí
    PCount = 0    #(BYTE PCount)// ÎïÆ·Êý
    PItemInfo = list()    #(vector<tagMCWeekPartyItem> PItemInfo)// ÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ActCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.ActCnt):
            value,_pos=CommFunc.ReadWORD(_lpData,_pos)
            self.TemplateList.append(value)
        self.PCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PCount):
            temPItemInfo = tagMCWeekPartyItem()
            _pos = temPItemInfo.ReadData(_lpData, _pos)
            self.PItemInfo.append(temPItemInfo)
        return _pos

    def Clear(self):
        self.ActCnt = 0
        self.TemplateList = list()
        self.PCount = 0
        self.PItemInfo = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2 * self.ActCnt
        length += 1
        for i in range(self.PCount):
            length += self.PItemInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.ActCnt)
        for i in range(self.ActCnt):
            data = CommFunc.WriteWORD(data, self.TemplateList[i])
        data = CommFunc.WriteBYTE(data, self.PCount)
        for i in range(self.PCount):
            data = CommFunc.WriteString(data, self.PItemInfo[i].GetLength(), self.PItemInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                ActCnt:%d,
                                TemplateList:%s,
                                PCount:%d,
                                PItemInfo:%s
                                '''\
                                %(
                                self.ActCnt,
                                "...",
                                self.PCount,
                                "..."
                                )
        return DumpString


class  tagMCWeekPartyInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    AdvanceMinutes = 0    #(WORD AdvanceMinutes)// ÌáÇ°ÏÔʾ·ÖÖÓ
    IsDayReset = 0    #(BYTE IsDayReset)//ÊÇ·ñÿÌìÖØÖÃ
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    DayCnt = 0    #(BYTE DayCnt)// ÌìÊý
    DayInfoList = list()    #(vector<tagMCWeekPartyDayInfo> DayInfoList)// ÿÌìÄ£°å
    TCount = 0    #(BYTE TCount)// Ä£°åÊý
    ActionInfo = list()    #(vector<tagMCWeekPartyAction> ActionInfo)// »î¶¯Ä£°åÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0A
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.AdvanceMinutes,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.DayCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.DayCnt):
            temDayInfoList = tagMCWeekPartyDayInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        self.TCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TCount):
            temActionInfo = tagMCWeekPartyAction()
            _pos = temActionInfo.ReadData(_lpData, _pos)
            self.ActionInfo.append(temActionInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0A
        self.StartDate = ""
        self.EndtDate = ""
        self.AdvanceMinutes = 0
        self.IsDayReset = 0
        self.ResetType = 0
        self.LimitLV = 0
        self.DayCnt = 0
        self.DayInfoList = list()
        self.TCount = 0
        self.ActionInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 2
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.DayCnt):
            length += self.DayInfoList[i].GetLength()
        length += 1
        for i in range(self.TCount):
            length += self.ActionInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteWORD(data, self.AdvanceMinutes)
        data = CommFunc.WriteBYTE(data, self.IsDayReset)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.DayCnt)
        for i in range(self.DayCnt):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.TCount)
        for i in range(self.TCount):
            data = CommFunc.WriteString(data, self.ActionInfo[i].GetLength(), self.ActionInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                AdvanceMinutes:%d,
                                IsDayReset:%d,
                                ResetType:%d,
                                LimitLV:%d,
                                DayCnt:%d,
                                DayInfoList:%s,
                                TCount:%d,
                                ActionInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.AdvanceMinutes,
                                self.IsDayReset,
                                self.ResetType,
                                self.LimitLV,
                                self.DayCnt,
                                "...",
                                self.TCount,
                                "..."
                                )
        return DumpString


m_NAtagMCWeekPartyInfo=tagMCWeekPartyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCWeekPartyInfo.Head.Cmd,m_NAtagMCWeekPartyInfo.Head.SubCmd))] = m_NAtagMCWeekPartyInfo


#------------------------------------------------------
# AA 0B ÖÜ¿ñ»¶Íæ¼Ò»î¶¯ÐÅÏ¢ #tagMCWeekPartyPlayerInfo

class  tagMCWeekPartyTaskInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("TemplateID", c_ushort),    # Ä£°åID
                  ("CurTimes", c_int),    #ÒÑÍê³É´ÎÊý
                  ("GotTimes", 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.TemplateID = 0
        self.CurTimes = 0
        self.GotTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCWeekPartyTaskInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 0B ÖÜ¿ñ»¶Íæ¼Ò»î¶¯ÐÅÏ¢ //tagMCWeekPartyPlayerInfo:
                                TemplateID:%d,
                                CurTimes:%d,
                                GotTimes:%d
                                '''\
                                %(
                                self.TemplateID,
                                self.CurTimes,
                                self.GotTimes
                                )
        return DumpString


class  tagMCWeekPartyDayPlayerInfo(Structure):
    DayIndex = 0    #(DWORD DayIndex)//µÚXÌì
    Point = 0    #(DWORD Point)//»ý·Ö
    AwardRecord = 0    #(DWORD AwardRecord)//»ý·ÖÁì½±¼Ç¼
    ACount = 0    #(DWORD ACount)//ÈÎÎñÌõÄ¿Êý
    TaskList = list()    #(vector<tagMCWeekPartyTaskInfo> TaskList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.DayIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Point,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ACount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        for i in range(self.ACount):
            temTaskList = tagMCWeekPartyTaskInfo()
            _pos = temTaskList.ReadData(_lpData, _pos)
            self.TaskList.append(temTaskList)
        return _pos

    def Clear(self):
        self.DayIndex = 0
        self.Point = 0
        self.AwardRecord = 0
        self.ACount = 0
        self.TaskList = list()
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 4
        length += 4
        for i in range(self.ACount):
            length += self.TaskList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.DayIndex)
        data = CommFunc.WriteDWORD(data, self.Point)
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteDWORD(data, self.ACount)
        for i in range(self.ACount):
            data = CommFunc.WriteString(data, self.TaskList[i].GetLength(), self.TaskList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                DayIndex:%d,
                                Point:%d,
                                AwardRecord:%d,
                                ACount:%d,
                                TaskList:%s
                                '''\
                                %(
                                self.DayIndex,
                                self.Point,
                                self.AwardRecord,
                                self.ACount,
                                "..."
                                )
        return DumpString


class  tagMCWeekPartyPlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    DayInfoList = list()    #(vector<tagMCWeekPartyDayPlayerInfo> DayInfoList)//»î¶¯Íê³É´ÎÊýÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0B
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temDayInfoList = tagMCWeekPartyDayPlayerInfo()
            _pos = temDayInfoList.ReadData(_lpData, _pos)
            self.DayInfoList.append(temDayInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAA
        self.Head.SubCmd = 0x0B
        self.Count = 0
        self.DayInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.DayInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.DayInfoList[i].GetLength(), self.DayInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                DayInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCWeekPartyPlayerInfo=tagMCWeekPartyPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCWeekPartyPlayerInfo.Head.Cmd,m_NAtagMCWeekPartyPlayerInfo.Head.SubCmd))] = m_NAtagMCWeekPartyPlayerInfo


#------------------------------------------------------
# AA 14 ÏɽçÊ¢µä³äÖµ´óÀñ #tagMCXJSDRecharge

class  tagMCXJSDRecharge(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("State", c_ubyte),    #0-²»¿ÉÁì 1-¿ÉÁì 2-ÒÑÁìÈ¡
                  ("CTGTotal", c_int),    #±¾´Î»î¶¯ÒÑÀۼƳäÖµ£¬µ¥Î»Ôª
                  ("FireworksBuyCount", c_ushort),    #ÒѹºÂò¸ß¼¶ÑÌ»¨Êý
                  ("FirewordsScore", c_int),    #µ±Ç°ÀÛ¼ÆËùÓÐÑÌ»¨×Ü»ý·Ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAA
        self.SubCmd = 0x14
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAA
        self.SubCmd = 0x14
        self.State = 0
        self.CTGTotal = 0
        self.FireworksBuyCount = 0
        self.FirewordsScore = 0
        return

    def GetLength(self):
        return sizeof(tagMCXJSDRecharge)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AA 14 ÏɽçÊ¢µä³äÖµ´óÀñ //tagMCXJSDRecharge:
                                Cmd:%s,
                                SubCmd:%s,
                                State:%d,
                                CTGTotal:%d,
                                FireworksBuyCount:%d,
                                FirewordsScore:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.State,
                                self.CTGTotal,
                                self.FireworksBuyCount,
                                self.FirewordsScore
                                )
        return DumpString


m_NAtagMCXJSDRecharge=tagMCXJSDRecharge()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCXJSDRecharge.Cmd,m_NAtagMCXJSDRecharge.SubCmd))] = m_NAtagMCXJSDRecharge


#------------------------------------------------------
# AB 01 BossÊ×ɱÍæ¼Ò½±ÀøÐÅÏ¢ #tagMCBossFirstKillStateInfo

class  tagMCBossFirstKillState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NPCID", c_int),    
                  ("FKState", c_int),    # Íæ¼Ò¸ÃbossÊ×ɱÏà¹Ø״̬£¬°´Î»´æ£º¸öλ-Íæ¼ÒÊÇ·ñ»÷ɱ¹ý£¬Ê®Î»-ÊÇ·ñÒÑÁìÈ¡Ê×ɱȫ·þ½±Àø£¬°Ùλ-ÊÇ·ñÒÑÁìÈ¡¸öÈËÊ×ɱ½±Àø
                  ]

    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.NPCID = 0
        self.FKState = 0
        return

    def GetLength(self):
        return sizeof(tagMCBossFirstKillState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 01 BossÊ×ɱÍæ¼Ò½±ÀøÐÅÏ¢ //tagMCBossFirstKillStateInfo:
                                NPCID:%d,
                                FKState:%d
                                '''\
                                %(
                                self.NPCID,
                                self.FKState
                                )
        return DumpString


class  tagMCBossFirstKillStateInfo(Structure):
    Head = tagHead()
    BossCount = 0    #(BYTE BossCount)
    FirstKillStateList = list()    #(vector<tagMCBossFirstKillState> FirstKillStateList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x01
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.BossCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BossCount):
            temFirstKillStateList = tagMCBossFirstKillState()
            _pos = temFirstKillStateList.ReadData(_lpData, _pos)
            self.FirstKillStateList.append(temFirstKillStateList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x01
        self.BossCount = 0
        self.FirstKillStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.BossCount):
            length += self.FirstKillStateList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.BossCount)
        for i in range(self.BossCount):
            data = CommFunc.WriteString(data, self.FirstKillStateList[i].GetLength(), self.FirstKillStateList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                BossCount:%d,
                                FirstKillStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.BossCount,
                                "..."
                                )
        return DumpString


m_NAtagMCBossFirstKillStateInfo=tagMCBossFirstKillStateInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBossFirstKillStateInfo.Head.Cmd,m_NAtagMCBossFirstKillStateInfo.Head.SubCmd))] = m_NAtagMCBossFirstKillStateInfo


#------------------------------------------------------
# AB 03 Boss¸´»îÍæ¼Ò»î¶¯ÐÅÏ¢ #tagMCBossRebornPlayerInfo

class  tagMCBossRebornData(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ActID", c_ubyte),    #»î¶¯ID
                  ("CurTimes", c_ushort),    #ÒÑÍê³É´ÎÊý
                  ("GotTimes", 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.ActID = 0
        self.CurTimes = 0
        self.GotTimes = 0
        return

    def GetLength(self):
        return sizeof(tagMCBossRebornData)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 03 Boss¸´»îÍæ¼Ò»î¶¯ÐÅÏ¢ //tagMCBossRebornPlayerInfo:
                                ActID:%d,
                                CurTimes:%d,
                                GotTimes:%d
                                '''\
                                %(
                                self.ActID,
                                self.CurTimes,
                                self.GotTimes
                                )
        return DumpString


class  tagMCBossRebornPlayerInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)//»î¶¯¸öÊý
    DataList = list()    #(vector<tagMCBossRebornData> DataList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temDataList = tagMCBossRebornData()
            _pos = temDataList.ReadData(_lpData, _pos)
            self.DataList.append(temDataList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x03
        self.Count = 0
        self.DataList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.DataList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.DataList[i].GetLength(), self.DataList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                DataList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCBossRebornPlayerInfo=tagMCBossRebornPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBossRebornPlayerInfo.Head.Cmd,m_NAtagMCBossRebornPlayerInfo.Head.SubCmd))] = m_NAtagMCBossRebornPlayerInfo


#------------------------------------------------------
# AB 04 Boss¸´»î»î¶¯ÐÅÏ¢ #tagMCBossRebornInfo

class  tagMCBossRebornAwardItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.ItemID = 0
        self.ItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagMCBossRebornAwardItem)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 04 Boss¸´»î»î¶¯ÐÅÏ¢ //tagMCBossRebornInfo:
                                ItemID:%d,
                                ItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.ItemID,
                                self.ItemCount,
                                self.IsBind
                                )
        return DumpString


class  tagMCBossRebornTaskInfo(Structure):
    TaskID = 0    #(BYTE TaskID)// id
    TotalTimes = 0    #(BYTE TotalTimes)// ¿ÉÍê³É×Ü´ÎÊý,0±íʾ²»ÏÞ´ÎÊý
    SingleTimes = 0    #(BYTE SingleTimes)// µ¥´ÎÁì½±ÐèÒª´ÎÊý
    AwardItemCount = 0    #(BYTE AwardItemCount)// ½±ÀøÎïÆ·Êý
    AwardItem = list()    #(vector<tagMCBossRebornAwardItem> AwardItem)// ½±ÀøÎïÆ·ÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.TaskID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TotalTimes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SingleTimes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardItemCount):
            temAwardItem = tagMCBossRebornAwardItem()
            _pos = temAwardItem.ReadData(_lpData, _pos)
            self.AwardItem.append(temAwardItem)
        return _pos

    def Clear(self):
        self.TaskID = 0
        self.TotalTimes = 0
        self.SingleTimes = 0
        self.AwardItemCount = 0
        self.AwardItem = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        length += 1
        for i in range(self.AwardItemCount):
            length += self.AwardItem[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.TaskID)
        data = CommFunc.WriteBYTE(data, self.TotalTimes)
        data = CommFunc.WriteBYTE(data, self.SingleTimes)
        data = CommFunc.WriteBYTE(data, self.AwardItemCount)
        for i in range(self.AwardItemCount):
            data = CommFunc.WriteString(data, self.AwardItem[i].GetLength(), self.AwardItem[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                TaskID:%d,
                                TotalTimes:%d,
                                SingleTimes:%d,
                                AwardItemCount:%d,
                                AwardItem:%s
                                '''\
                                %(
                                self.TaskID,
                                self.TotalTimes,
                                self.SingleTimes,
                                self.AwardItemCount,
                                "..."
                                )
        return DumpString


class  tagMCBossRebornInfo(Structure):
    Head = tagHead()
    StartDate = ""    #(char StartDate[10])// ¿ªÊ¼ÈÕÆÚ y-m-d
    EndtDate = ""    #(char EndtDate[10])// ½áÊøÈÕÆÚ y-m-d
    ResetType = 0    #(BYTE ResetType)// ÖØÖÃÀàÐÍ£¬0-0µãÖØÖã»1-5µãÖØÖÃ
    LimitLV = 0    #(WORD LimitLV)// ÏÞÖƵȼ¶
    TaskCnt = 0    #(BYTE TaskCnt)
    TaskInfo = list()    #(vector<tagMCBossRebornTaskInfo> TaskInfo)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TaskCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.TaskCnt):
            temTaskInfo = tagMCBossRebornTaskInfo()
            _pos = temTaskInfo.ReadData(_lpData, _pos)
            self.TaskInfo.append(temTaskInfo)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x04
        self.StartDate = ""
        self.EndtDate = ""
        self.ResetType = 0
        self.LimitLV = 0
        self.TaskCnt = 0
        self.TaskInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 10
        length += 10
        length += 1
        length += 2
        length += 1
        for i in range(self.TaskCnt):
            length += self.TaskInfo[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteString(data, 10, self.StartDate)
        data = CommFunc.WriteString(data, 10, self.EndtDate)
        data = CommFunc.WriteBYTE(data, self.ResetType)
        data = CommFunc.WriteWORD(data, self.LimitLV)
        data = CommFunc.WriteBYTE(data, self.TaskCnt)
        for i in range(self.TaskCnt):
            data = CommFunc.WriteString(data, self.TaskInfo[i].GetLength(), self.TaskInfo[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartDate:%s,
                                EndtDate:%s,
                                ResetType:%d,
                                LimitLV:%d,
                                TaskCnt:%d,
                                TaskInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartDate,
                                self.EndtDate,
                                self.ResetType,
                                self.LimitLV,
                                self.TaskCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCBossRebornInfo=tagMCBossRebornInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBossRebornInfo.Head.Cmd,m_NAtagMCBossRebornInfo.Head.SubCmd))] = m_NAtagMCBossRebornInfo


#------------------------------------------------------
# AB 23 Ò¡÷»×Ó½±Àø»Ø°ü #tagMCDiceAward

class  tagMCDiceAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AwardCnt", c_ubyte),    # Ì«¼«ÊýÁ¿
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAB
        self.SubCmd = 0x23
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAB
        self.SubCmd = 0x23
        self.AwardCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCDiceAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 23 Ò¡÷»×Ó½±Àø»Ø°ü //tagMCDiceAward:
                                Cmd:%s,
                                SubCmd:%s,
                                AwardCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AwardCnt
                                )
        return DumpString


m_NAtagMCDiceAward=tagMCDiceAward()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDiceAward.Cmd,m_NAtagMCDiceAward.SubCmd))] = m_NAtagMCDiceAward


#------------------------------------------------------
# AB 25 ½ÚÈÕºì°üÐÅÏ¢ #tagMCFeastRedPackInfo

class  tagMCFeastRedPackInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MoneyNum", c_int),    # ÀÛ»ýÇÀµ½¶àÉÙÇ®
                  ("GrabCnt", c_ushort),    # ÒÑÇÀºì°ü´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAB
        self.SubCmd = 0x25
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAB
        self.SubCmd = 0x25
        self.MoneyNum = 0
        self.GrabCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFeastRedPackInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 25 ½ÚÈÕºì°üÐÅÏ¢ //tagMCFeastRedPackInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                MoneyNum:%d,
                                GrabCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MoneyNum,
                                self.GrabCnt
                                )
        return DumpString


m_NAtagMCFeastRedPackInfo=tagMCFeastRedPackInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFeastRedPackInfo.Cmd,m_NAtagMCFeastRedPackInfo.SubCmd))] = m_NAtagMCFeastRedPackInfo


#------------------------------------------------------
# AB 17 ¿ª·þ»î¶¯½±Àø״̬ #tagMCOpenServerCampaignAwardList

class  tagMCOpenServerCampaignAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("CampaignType", c_ubyte),    #½±ÀøÀàÐÍ
                  ("BillAwardRecord", c_ubyte),    #ÅÅÐн±ÀøÊÇ·ñÒÑÁìÈ¡
                  ("TagAwardRecord", c_int),    #Ä¿±ê½±ÀøË÷ÒýλÁìÈ¡¼Ç¼£º0-δÁ죻1-ÒÑÁì
                  ("RecordData", 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.CampaignType = 0
        self.BillAwardRecord = 0
        self.TagAwardRecord = 0
        self.RecordData = 0
        return

    def GetLength(self):
        return sizeof(tagMCOpenServerCampaignAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 17 ¿ª·þ»î¶¯½±Àø״̬ //tagMCOpenServerCampaignAwardList:
                                CampaignType:%d,
                                BillAwardRecord:%d,
                                TagAwardRecord:%d,
                                RecordData:%d
                                '''\
                                %(
                                self.CampaignType,
                                self.BillAwardRecord,
                                self.TagAwardRecord,
                                self.RecordData
                                )
        return DumpString


class  tagMCOpenServerCampaignAwardList(Structure):
    Head = tagHead()
    OSCAwardCnt = 0    #(BYTE OSCAwardCnt)//½±ÀøÀàÐÍÊý
    OSCAwardList = list()    #(vector<tagMCOpenServerCampaignAward> OSCAwardList)// ½±Àø״̬Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OSCAwardCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.OSCAwardCnt):
            temOSCAwardList = tagMCOpenServerCampaignAward()
            _pos = temOSCAwardList.ReadData(_lpData, _pos)
            self.OSCAwardList.append(temOSCAwardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xAB
        self.Head.SubCmd = 0x17
        self.OSCAwardCnt = 0
        self.OSCAwardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.OSCAwardCnt):
            length += self.OSCAwardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.OSCAwardCnt)
        for i in range(self.OSCAwardCnt):
            data = CommFunc.WriteString(data, self.OSCAwardList[i].GetLength(), self.OSCAwardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OSCAwardCnt:%d,
                                OSCAwardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OSCAwardCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCOpenServerCampaignAwardList=tagMCOpenServerCampaignAwardList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOpenServerCampaignAwardList.Head.Cmd,m_NAtagMCOpenServerCampaignAwardList.Head.SubCmd))] = m_NAtagMCOpenServerCampaignAwardList


#------------------------------------------------------
# AB 24 ¿ª·þºì°üÐÅÏ¢ #tagMCOpenServerRedPacketInfo

class  tagMCOpenServerRedPacketInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MoneyNum", c_int),    # ÀÛ»ýÇÀµ½¶àÉÙÇ®
                  ("GrabCnt", c_ushort),    # ÒÑÇÀºì°ü´ÎÊý
                  ("StartTime", c_int),    # ¿ªÊ¼µ¹¼Æʱʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAB
        self.SubCmd = 0x24
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAB
        self.SubCmd = 0x24
        self.MoneyNum = 0
        self.GrabCnt = 0
        self.StartTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCOpenServerRedPacketInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 24 ¿ª·þºì°üÐÅÏ¢ //tagMCOpenServerRedPacketInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                MoneyNum:%d,
                                GrabCnt:%d,
                                StartTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MoneyNum,
                                self.GrabCnt,
                                self.StartTime
                                )
        return DumpString


m_NAtagMCOpenServerRedPacketInfo=tagMCOpenServerRedPacketInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOpenServerRedPacketInfo.Cmd,m_NAtagMCOpenServerRedPacketInfo.SubCmd))] = m_NAtagMCOpenServerRedPacketInfo


#------------------------------------------------------
# AB 19 Á¶Öƽ±ÀøÐÅÏ¢ #tagMCRefineGiftInfo

class  tagMCRefineGiftInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ExpRefineStartTime", c_int),    # ¾­ÑéÁ¶Öƻ¿ªÊ¼Ê±¼ä
                  ("MoneyRefineStartTime", c_int),    # ½ð±ÒÁ¶Öƻ¿ªÊ¼Ê±¼ä
                  ("ExpRefineCnt", c_ubyte),    # ¾­ÑéÒÑÁ¶ÖÆ´ÎÊý
                  ("MoneyRefineCnt", c_ubyte),    # ½ð±ÒÒÑÁ¶ÖÆ´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAB
        self.SubCmd = 0x19
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAB
        self.SubCmd = 0x19
        self.ExpRefineStartTime = 0
        self.MoneyRefineStartTime = 0
        self.ExpRefineCnt = 0
        self.MoneyRefineCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCRefineGiftInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 19 Á¶Öƽ±ÀøÐÅÏ¢ //tagMCRefineGiftInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ExpRefineStartTime:%d,
                                MoneyRefineStartTime:%d,
                                ExpRefineCnt:%d,
                                MoneyRefineCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ExpRefineStartTime,
                                self.MoneyRefineStartTime,
                                self.ExpRefineCnt,
                                self.MoneyRefineCnt
                                )
        return DumpString


m_NAtagMCRefineGiftInfo=tagMCRefineGiftInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRefineGiftInfo.Cmd,m_NAtagMCRefineGiftInfo.SubCmd))] = m_NAtagMCRefineGiftInfo


#------------------------------------------------------
# AB 22 Ò¡÷»×Ó½á¹û #tagMCDiceExResult

class  tagMCDiceExResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ResultNum", c_int),    # ÷»×Ó½á¹û
                  ("DiceType", c_ubyte),    # 0-Õý³£ 1-¸ÄͶ 2-ÖØÖÃ
                  ("UseFreeCnt", c_ubyte),    # ¸ÄͶʹÓôÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAB
        self.SubCmd = 0x22
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAB
        self.SubCmd = 0x22
        self.ResultNum = 0
        self.DiceType = 0
        self.UseFreeCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCDiceExResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AB 22 Ò¡÷»×Ó½á¹û //tagMCDiceExResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ResultNum:%d,
                                DiceType:%d,
                                UseFreeCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ResultNum,
                                self.DiceType,
                                self.UseFreeCnt
                                )
        return DumpString


m_NAtagMCDiceExResult=tagMCDiceExResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDiceExResult.Cmd,m_NAtagMCDiceExResult.SubCmd))] = m_NAtagMCDiceExResult


#------------------------------------------------------
# AE 04 ×Ô¶¯ÔËïÚ״̬#tagPyAutoTruckState

class  tagPyAutoTruckState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("State", c_ubyte),    
                  ("Result", c_ubyte),    #³É¹¦/ʧ°Ü
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAE
        self.SubCmd = 0x04
        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 = 0xAE
        self.SubCmd = 0x04
        self.State = 0
        self.Result = 0
        return

    def GetLength(self):
        return sizeof(tagPyAutoTruckState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AE 04 ×Ô¶¯ÔËïÚ״̬//tagPyAutoTruckState:
                                Cmd:%s,
                                SubCmd:%s,
                                State:%d,
                                Result:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.State,
                                self.Result
                                )
        return DumpString


m_NAtagPyAutoTruckState=tagPyAutoTruckState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagPyAutoTruckState.Cmd,m_NAtagPyAutoTruckState.SubCmd))] = m_NAtagPyAutoTruckState


#------------------------------------------------------
# AE 01 ¿ÉÕÙ»½ïÚ³µµÈ¼¶#tagPyCanSummonTruckLV

class  tagPyCanSummonTruckLV(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("TruckLV", c_ubyte),    #ïÚ³µµÈ¼¶
                  ("FreeCnt", c_ubyte),    #µ±ÈÕÒÑÃâ·ÑˢдÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAE
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAE
        self.SubCmd = 0x01
        self.TruckLV = 0
        self.FreeCnt = 0
        return

    def GetLength(self):
        return sizeof(tagPyCanSummonTruckLV)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AE 01 ¿ÉÕÙ»½ïÚ³µµÈ¼¶//tagPyCanSummonTruckLV:
                                Cmd:%s,
                                SubCmd:%s,
                                TruckLV:%d,
                                FreeCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.TruckLV,
                                self.FreeCnt
                                )
        return DumpString


m_NAtagPyCanSummonTruckLV=tagPyCanSummonTruckLV()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagPyCanSummonTruckLV.Cmd,m_NAtagPyCanSummonTruckLV.SubCmd))] = m_NAtagPyCanSummonTruckLV


#------------------------------------------------------
# AE 02 ½ÙïÚ´ÎÊý#tagPyDestroyTruckCnt

class  tagPyDestroyTruckCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Count", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAE
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAE
        self.SubCmd = 0x02
        self.Count = 0
        return

    def GetLength(self):
        return sizeof(tagPyDestroyTruckCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AE 02 ½ÙïÚ´ÎÊý//tagPyDestroyTruckCnt:
                                Cmd:%s,
                                SubCmd:%s,
                                Count:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Count
                                )
        return DumpString


m_NAtagPyDestroyTruckCnt=tagPyDestroyTruckCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagPyDestroyTruckCnt.Cmd,m_NAtagPyDestroyTruckCnt.SubCmd))] = m_NAtagPyDestroyTruckCnt


#------------------------------------------------------
# AE 06 ÔËïÚ½±Àø #tagMCTruckAward

class  tagMCTruckAward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AwardType", c_ubyte),    # ½±ÀøÀàÐÍ£¬0-ÔËïÚ£»1-½ÙïÚ
                  ("Exp", c_int),    
                  ("ExpPoint", c_int),    
                  ("ZhenQi", c_int),    
                  ("Prestige", c_int),    
                  ("MoneyType", c_ubyte),    
                  ("MoneyCnt", c_int),    
                  ("IsDestroy", c_ubyte),    # ÊÇ·ñ±»½Ù
                  ("IsDouble", c_ubyte),    # ÊÇ·ñË«±¶
                  ("IsTimeOut", c_ubyte),    # ÊÇ·ñ³¬Ê±
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAE
        self.SubCmd = 0x06
        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 = 0xAE
        self.SubCmd = 0x06
        self.AwardType = 0
        self.Exp = 0
        self.ExpPoint = 0
        self.ZhenQi = 0
        self.Prestige = 0
        self.MoneyType = 0
        self.MoneyCnt = 0
        self.IsDestroy = 0
        self.IsDouble = 0
        self.IsTimeOut = 0
        return

    def GetLength(self):
        return sizeof(tagMCTruckAward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AE 06 ÔËïÚ½±Àø //tagMCTruckAward:
                                Cmd:%s,
                                SubCmd:%s,
                                AwardType:%d,
                                Exp:%d,
                                ExpPoint:%d,
                                ZhenQi:%d,
                                Prestige:%d,
                                MoneyType:%d,
                                MoneyCnt:%d,
                                IsDestroy:%d,
                                IsDouble:%d,
                                IsTimeOut:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AwardType,
                                self.Exp,
                                self.ExpPoint,
                                self.ZhenQi,
                                self.Prestige,
                                self.MoneyType,
                                self.MoneyCnt,
                                self.IsDestroy,
                                self.IsDouble,
                                self.IsTimeOut
                                )
        return DumpString


m_NAtagMCTruckAward=tagMCTruckAward()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTruckAward.Cmd,m_NAtagMCTruckAward.SubCmd))] = m_NAtagMCTruckAward


#------------------------------------------------------
# AE 03 ïÚ³µ×´Ì¬Ä£Ê½#tagPyTruckMode

class  tagPyTruckMode(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("TruckMode", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAE
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAE
        self.SubCmd = 0x03
        self.TruckMode = 0
        return

    def GetLength(self):
        return sizeof(tagPyTruckMode)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AE 03 ïÚ³µ×´Ì¬Ä£Ê½//tagPyTruckMode:
                                Cmd:%s,
                                SubCmd:%s,
                                TruckMode:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.TruckMode
                                )
        return DumpString


m_NAtagPyTruckMode=tagPyTruckMode()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagPyTruckMode.Cmd,m_NAtagPyTruckMode.SubCmd))] = m_NAtagPyTruckMode


#------------------------------------------------------
# AF 02 ºÏ·þ»î¶¯½±Àø״̬ #tagMCMixCampaignAwardRecord

class  tagMCMixCampaignAwardRecord(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("CampaignType", c_ubyte),    #½±ÀøÀàÐÍ
                  ("Record", c_int),    #´ÓµÍλµ½¸ßλ£¬Ã¿Î»±íʾ£º0-²»¿ÉÁ죻1-ÁìÈ¡£»2-ÒÑÁì
                  ("RecordData", c_int),    #»î¶¯Ê±µÄ¼Ç¼ֵ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAF
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAF
        self.SubCmd = 0x02
        self.CampaignType = 0
        self.Record = 0
        self.RecordData = 0
        return

    def GetLength(self):
        return sizeof(tagMCMixCampaignAwardRecord)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AF 02 ºÏ·þ»î¶¯½±Àø״̬ //tagMCMixCampaignAwardRecord:
                                Cmd:%s,
                                SubCmd:%s,
                                CampaignType:%d,
                                Record:%d,
                                RecordData:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.CampaignType,
                                self.Record,
                                self.RecordData
                                )
        return DumpString


m_NAtagMCMixCampaignAwardRecord=tagMCMixCampaignAwardRecord()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMixCampaignAwardRecord.Cmd,m_NAtagMCMixCampaignAwardRecord.SubCmd))] = m_NAtagMCMixCampaignAwardRecord


#------------------------------------------------------
# AF 01 ºÏ·þµ±ÌìµÇ½½±ÀøÁìȡ״̬ # tagMCMixLoginDayAwardState

class  tagMCMixLoginDayAwardState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("State", c_int),    # Áìȡ״̬ <°´Î»È¡Öµ,0-δÁìÈ¡ 1-¿ÉÁìÈ¡ 2-ÒÑÁìÈ¡>
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xAF
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xAF
        self.SubCmd = 0x01
        self.State = 0
        return

    def GetLength(self):
        return sizeof(tagMCMixLoginDayAwardState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// AF 01 ºÏ·þµ±ÌìµÇ½½±ÀøÁìȡ״̬ // tagMCMixLoginDayAwardState:
                                Cmd:%s,
                                SubCmd:%s,
                                State:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.State
                                )
        return DumpString


m_NAtagMCMixLoginDayAwardState=tagMCMixLoginDayAwardState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMixLoginDayAwardState.Cmd,m_NAtagMCMixLoginDayAwardState.SubCmd))] = m_NAtagMCMixLoginDayAwardState


#------------------------------------------------------
# B0 27 »îÔ¾·ÅÖÃÐÅÏ¢ #tagMCActivityPlaceInfo

class  tagMCActivityPlaceInfo(Structure):
    Head = tagHead()
    StartTime = 0    #(DWORD StartTime)// ¿ªÊ¼Ì½Ë÷timeʱ¼ä´Á£¬Íê³ÉÒ»´Î̽Ë÷»á×Ô¶¯ÏÂÒ»´Î̽Ë÷²¢¸üиÃʱ¼ä
    PlaceCount = 0    #(BYTE PlaceCount)// Ê£ÓàδÍê³É̽Ë÷´ÎÊý
    RewardCount = 0    #(BYTE RewardCount)// ÀÛ¼ÆδÁìȡ̽Ë÷½±Àø´ÎÊý
    RewardLen = 0    #(BYTE RewardLen)
    RewardInfo = ""    #(String RewardInfo)//ÀÛ¼ÆδÁìȡ̽Ë÷½±Àø [[itemID, count], ...]
    TodayExp = 0    #(DWORD TodayExp)
    TodayExpPoint = 0    #(DWORD TodayExpPoint)
    YestordayExp = 0    #(DWORD YestordayExp)
    YestordayExpPoint = 0    #(DWORD YestordayExpPoint)
    TotalCount = 0    #(DWORD TotalCount)// ÀۼƻîÔ¾·ÅÖôÎÊý
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x27
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.StartTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlaceCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RewardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RewardLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RewardInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.RewardLen)
        self.TodayExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TodayExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.YestordayExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.YestordayExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x27
        self.StartTime = 0
        self.PlaceCount = 0
        self.RewardCount = 0
        self.RewardLen = 0
        self.RewardInfo = ""
        self.TodayExp = 0
        self.TodayExpPoint = 0
        self.YestordayExp = 0
        self.YestordayExpPoint = 0
        self.TotalCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        length += 1
        length += len(self.RewardInfo)
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.StartTime)
        data = CommFunc.WriteBYTE(data, self.PlaceCount)
        data = CommFunc.WriteBYTE(data, self.RewardCount)
        data = CommFunc.WriteBYTE(data, self.RewardLen)
        data = CommFunc.WriteString(data, self.RewardLen, self.RewardInfo)
        data = CommFunc.WriteDWORD(data, self.TodayExp)
        data = CommFunc.WriteDWORD(data, self.TodayExpPoint)
        data = CommFunc.WriteDWORD(data, self.YestordayExp)
        data = CommFunc.WriteDWORD(data, self.YestordayExpPoint)
        data = CommFunc.WriteDWORD(data, self.TotalCount)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                StartTime:%d,
                                PlaceCount:%d,
                                RewardCount:%d,
                                RewardLen:%d,
                                RewardInfo:%s,
                                TodayExp:%d,
                                TodayExpPoint:%d,
                                YestordayExp:%d,
                                YestordayExpPoint:%d,
                                TotalCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.StartTime,
                                self.PlaceCount,
                                self.RewardCount,
                                self.RewardLen,
                                self.RewardInfo,
                                self.TodayExp,
                                self.TodayExpPoint,
                                self.YestordayExp,
                                self.YestordayExpPoint,
                                self.TotalCount
                                )
        return DumpString


m_NAtagMCActivityPlaceInfo=tagMCActivityPlaceInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActivityPlaceInfo.Head.Cmd,m_NAtagMCActivityPlaceInfo.Head.SubCmd))] = m_NAtagMCActivityPlaceInfo


#------------------------------------------------------
#B0 25 ¼Ò×åÐüÉÍÈÎÎñ½±ÀøÁìÈ¡Çé¿ö #tagFamilyArrestAwardReceiveState

class  tagFamilyArrestAwardReceiveState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ReceiveState", c_int),    #ÐüÉÍÈÎÎñ½±ÀøÁìÈ¡Çé¿ö
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB0
        self.SubCmd = 0x25
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB0
        self.SubCmd = 0x25
        self.ReceiveState = 0
        return

    def GetLength(self):
        return sizeof(tagFamilyArrestAwardReceiveState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B0 25 ¼Ò×åÐüÉÍÈÎÎñ½±ÀøÁìÈ¡Çé¿ö //tagFamilyArrestAwardReceiveState:
                                Cmd:%s,
                                SubCmd:%s,
                                ReceiveState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ReceiveState
                                )
        return DumpString


m_NAtagFamilyArrestAwardReceiveState=tagFamilyArrestAwardReceiveState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagFamilyArrestAwardReceiveState.Cmd,m_NAtagFamilyArrestAwardReceiveState.SubCmd))] = m_NAtagFamilyArrestAwardReceiveState


#------------------------------------------------------
# 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 30 Íæ¼Ò¸£µØÏà¹ØÐÅÏ¢ #tagMCPlayerMineAreaInfo

class  tagMCPlayerMineAreaInfo(Structure):
    Head = tagHead()
    WorkerCount = 0    #(BYTE WorkerCount)// ÒѹÍÓ¶¹¤ÈËÊý
    EnergyUsed = 0    #(WORD EnergyUsed)// ½ñÈÕÒÑÏûºÄÌåÁ¦
    RefreshCount = 0    #(DWORD RefreshCount)// ½ñÈÕ¸£µØË¢ÐÂÎïÆ·´ÎÊý - ÆÕͨˢÐÂ
    RefreshCountSuper = 0    #(BYTE RefreshCountSuper)// ½ñÈÕ¸£µØË¢ÐÂÎïÆ·´ÎÊý - ³¬¼¶Ë¢ÐÂ
    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)// ½ñÈÕÒÑ°ïÖú±ðÈ˽±Àø´ÎÊý
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB0
        self.Head.SubCmd = 0x30
        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.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)
        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.TreasureCount = 0
        self.TreasureState = list()
        self.TreasureAward = list()
        self.TreasureProgress = list()
        self.HelpAwardCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 2
        length += 4
        length += 1
        length += 1
        length += 1 * self.TreasureCount
        length += 1 * self.TreasureCount
        length += 1 * self.TreasureCount
        length += 1

        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.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)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                WorkerCount:%d,
                                EnergyUsed:%d,
                                RefreshCount:%d,
                                RefreshCountSuper:%d,
                                TreasureCount:%d,
                                TreasureState:%s,
                                TreasureAward:%s,
                                TreasureProgress:%s,
                                HelpAwardCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.WorkerCount,
                                self.EnergyUsed,
                                self.RefreshCount,
                                self.RefreshCountSuper,
                                self.TreasureCount,
                                "...",
                                "...",
                                "...",
                                self.HelpAwardCount
                                )
        return DumpString


m_NAtagMCPlayerMineAreaInfo=tagMCPlayerMineAreaInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerMineAreaInfo.Head.Cmd,m_NAtagMCPlayerMineAreaInfo.Head.SubCmd))] = m_NAtagMCPlayerMineAreaInfo


#------------------------------------------------------
# B0 07 ½ñÈÕЭÖú»îÔ¾ÁîÐÅÏ¢ #tagMCTodayAssistMoneyInfo

class  tagMCTodayAssistMoneyInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("TodayAssistMoney", c_ushort),    #½ñÈÕÒÑ»ñµÃ»îÔ¾Á²»º¬Éç½»¼Ó³É
                  ("SocialMoney", c_ushort),    #Éç½»¶îÍâ¼Ó³É
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB0
        self.SubCmd = 0x07
        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 = 0x07
        self.TodayAssistMoney = 0
        self.SocialMoney = 0
        return

    def GetLength(self):
        return sizeof(tagMCTodayAssistMoneyInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B0 07 ½ñÈÕЭÖú»îÔ¾ÁîÐÅÏ¢ //tagMCTodayAssistMoneyInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                TodayAssistMoney:%d,
                                SocialMoney:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.TodayAssistMoney,
                                self.SocialMoney
                                )
        return DumpString


m_NAtagMCTodayAssistMoneyInfo=tagMCTodayAssistMoneyInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTodayAssistMoneyInfo.Cmd,m_NAtagMCTodayAssistMoneyInfo.SubCmd))] = m_NAtagMCTodayAssistMoneyInfo


#------------------------------------------------------
# B1 02 Íæ¼ÒʱװƤ·ô¼¤»î״̬ #tagMCClothesCoatSkinState

class  tagMCClothesCoatLVInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("CoatIndex", c_int),    #ʱװË÷Òý
                  ("CoatLV", c_ubyte),    #ʱװµÈ¼¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.CoatIndex = 0
        self.CoatLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCClothesCoatLVInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 02 Íæ¼ÒʱװƤ·ô¼¤»î״̬ //tagMCClothesCoatSkinState:
                                CoatIndex:%d,
                                CoatLV:%d
                                '''\
                                %(
                                self.CoatIndex,
                                self.CoatLV
                                )
        return DumpString


class  tagMCClothesCoatSkinState(Structure):
    Head = tagHead()
    CoatChestLV = 0    #(DWORD CoatChestLV)//ʱװ¹ñµÈ¼¶
    CoatChestExp = 0    #(DWORD CoatChestExp)//ʱװ¹ñ¾­Ñé
    CoatNum = 0    #(WORD CoatNum)//ʱװ¸öÊý
    CoatInfoList = list()    #(vector<tagMCClothesCoatLVInfo> CoatInfoList)// ʱװÊý¾ÝÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x02
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.CoatChestLV,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CoatChestExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CoatNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.CoatNum):
            temCoatInfoList = tagMCClothesCoatLVInfo()
            _pos = temCoatInfoList.ReadData(_lpData, _pos)
            self.CoatInfoList.append(temCoatInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x02
        self.CoatChestLV = 0
        self.CoatChestExp = 0
        self.CoatNum = 0
        self.CoatInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 2
        for i in range(self.CoatNum):
            length += self.CoatInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.CoatChestLV)
        data = CommFunc.WriteDWORD(data, self.CoatChestExp)
        data = CommFunc.WriteWORD(data, self.CoatNum)
        for i in range(self.CoatNum):
            data = CommFunc.WriteString(data, self.CoatInfoList[i].GetLength(), self.CoatInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                CoatChestLV:%d,
                                CoatChestExp:%d,
                                CoatNum:%d,
                                CoatInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.CoatChestLV,
                                self.CoatChestExp,
                                self.CoatNum,
                                "..."
                                )
        return DumpString


m_NAtagMCClothesCoatSkinState=tagMCClothesCoatSkinState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCClothesCoatSkinState.Head.Cmd,m_NAtagMCClothesCoatSkinState.Head.SubCmd))] = m_NAtagMCClothesCoatSkinState


#------------------------------------------------------
# B1 17 Í·ÏñÐÅÏ¢ #tagMCFaceInfo

class  tagMCFace(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FaceID", c_int),    #Í·ÏñID
                  ("State", c_ubyte),    #ÊÇ·ñÒѼ¤»î
                  ("EndTime", c_int),    #µ½ÆÚʱ¼ä´Á£¬0ΪÓÀ¾Ã
                  ("Star", c_ubyte),    #ÐǼ¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.FaceID = 0
        self.State = 0
        self.EndTime = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCFace)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 17 Í·ÏñÐÅÏ¢ //tagMCFaceInfo:
                                FaceID:%d,
                                State:%d,
                                EndTime:%d,
                                Star:%d
                                '''\
                                %(
                                self.FaceID,
                                self.State,
                                self.EndTime,
                                self.Star
                                )
        return DumpString


class  tagMCFaceInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    FaceList = list()    #(vector<tagMCFace> FaceList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x17
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temFaceList = tagMCFace()
            _pos = temFaceList.ReadData(_lpData, _pos)
            self.FaceList.append(temFaceList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x17
        self.Count = 0
        self.FaceList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.FaceList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.FaceList[i].GetLength(), self.FaceList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                FaceList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFaceInfo=tagMCFaceInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFaceInfo.Head.Cmd,m_NAtagMCFaceInfo.Head.SubCmd))] = m_NAtagMCFaceInfo


#------------------------------------------------------
# B1 18 Í·Ïñ¿òÐÅÏ¢ #tagMCFacePicInfo

class  tagMCFacePic(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FacePicID", c_int),    #Í·Ïñ¿òID
                  ("State", c_ubyte),    #ÊÇ·ñÒѼ¤»î
                  ("EndTime", c_int),    #µ½ÆÚʱ¼ä´Á£¬0ΪÓÀ¾Ã
                  ("Star", c_ubyte),    #ÐǼ¶
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.FacePicID = 0
        self.State = 0
        self.EndTime = 0
        self.Star = 0
        return

    def GetLength(self):
        return sizeof(tagMCFacePic)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 18 Í·Ïñ¿òÐÅÏ¢ //tagMCFacePicInfo:
                                FacePicID:%d,
                                State:%d,
                                EndTime:%d,
                                Star:%d
                                '''\
                                %(
                                self.FacePicID,
                                self.State,
                                self.EndTime,
                                self.Star
                                )
        return DumpString


class  tagMCFacePicInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    FacePicList = list()    #(vector<tagMCFacePic> FacePicList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x18
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temFacePicList = tagMCFacePic()
            _pos = temFacePicList.ReadData(_lpData, _pos)
            self.FacePicList.append(temFacePicList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x18
        self.Count = 0
        self.FacePicList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.FacePicList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.FacePicList[i].GetLength(), self.FacePicList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                FacePicList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCFacePicInfo=tagMCFacePicInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFacePicInfo.Head.Cmd,m_NAtagMCFacePicInfo.Head.SubCmd))] = m_NAtagMCFacePicInfo


#------------------------------------------------------
# B1 11 ¹¦ÄÜϵͳÌØȨÐÅÏ¢ #tagMCFuncSysPrivilegeInfoList

class  tagMCFuncSysPrivilegeInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FuncSysID", c_ubyte),    # ¹¦ÄÜϵͳID
                  ("ActivateTime", c_int),    # ¼¤»îʱ¼ä´Á
                  ("AwardState", 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.FuncSysID = 0
        self.ActivateTime = 0
        self.AwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCFuncSysPrivilegeInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 11 ¹¦ÄÜϵͳÌØȨÐÅÏ¢ //tagMCFuncSysPrivilegeInfoList:
                                FuncSysID:%d,
                                ActivateTime:%d,
                                AwardState:%d
                                '''\
                                %(
                                self.FuncSysID,
                                self.ActivateTime,
                                self.AwardState
                                )
        return DumpString


class  tagMCFuncSysPrivilegeInfoList(Structure):
    Head = tagHead()
    PrivilegeCount = 0    #(BYTE PrivilegeCount)// ÌØȨ¸öÊý
    PrivilegeInfoList = list()    #(vector<tagMCFuncSysPrivilegeInfo> PrivilegeInfoList)// ÌØȨÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x11
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PrivilegeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PrivilegeCount):
            temPrivilegeInfoList = tagMCFuncSysPrivilegeInfo()
            _pos = temPrivilegeInfoList.ReadData(_lpData, _pos)
            self.PrivilegeInfoList.append(temPrivilegeInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x11
        self.PrivilegeCount = 0
        self.PrivilegeInfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.PrivilegeCount):
            length += self.PrivilegeInfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PrivilegeCount)
        for i in range(self.PrivilegeCount):
            data = CommFunc.WriteString(data, self.PrivilegeInfoList[i].GetLength(), self.PrivilegeInfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PrivilegeCount:%d,
                                PrivilegeInfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PrivilegeCount,
                                "..."
                                )
        return DumpString


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


#------------------------------------------------------
# B1 06 ֪ͨÍæ¼ÒÏòÄ¿±êµãÒƶ¯ #tagMCNotifyPlayerMove

class  tagMCNotifyPlayerMove(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PosX", c_int),    
                  ("PosY", c_int),    
                  ("NPCID", c_int),    #Ä¿±êµãѰ·NPCID, ¿ÉÄÜΪ0
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB1
        self.SubCmd = 0x06
        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 = 0xB1
        self.SubCmd = 0x06
        self.PosX = 0
        self.PosY = 0
        self.NPCID = 0
        return

    def GetLength(self):
        return sizeof(tagMCNotifyPlayerMove)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 06 ֪ͨÍæ¼ÒÏòÄ¿±êµãÒƶ¯ //tagMCNotifyPlayerMove:
                                Cmd:%s,
                                SubCmd:%s,
                                PosX:%d,
                                PosY:%d,
                                NPCID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PosX,
                                self.PosY,
                                self.NPCID
                                )
        return DumpString


m_NAtagMCNotifyPlayerMove=tagMCNotifyPlayerMove()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifyPlayerMove.Cmd,m_NAtagMCNotifyPlayerMove.SubCmd))] = m_NAtagMCNotifyPlayerMove


#------------------------------------------------------
# B1 13 ÔÚÏß½±ÀøÐÅϢР#tagMCOnlinePrizeNew

class  tagMCOnlinePrizeNew(Structure):
    Head = tagHead()
    OnlineTime = 0    #(DWORD OnlineTime)//ÔÚÏßʱ¼äºÁÃë
    Len = 0    #(BYTE Len)
    PrizeInfo = list()    #(vector<DWORD> PrizeInfo)//Áì½±¼Ç¼
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OnlineTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Len):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.PrizeInfo.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x13
        self.OnlineTime = 0
        self.Len = 0
        self.PrizeInfo = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 4 * self.Len

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.OnlineTime)
        data = CommFunc.WriteBYTE(data, self.Len)
        for i in range(self.Len):
            data = CommFunc.WriteDWORD(data, self.PrizeInfo[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OnlineTime:%d,
                                Len:%d,
                                PrizeInfo:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OnlineTime,
                                self.Len,
                                "..."
                                )
        return DumpString


m_NAtagMCOnlinePrizeNew=tagMCOnlinePrizeNew()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOnlinePrizeNew.Head.Cmd,m_NAtagMCOnlinePrizeNew.Head.SubCmd))] = m_NAtagMCOnlinePrizeNew


#------------------------------------------------------
# B1 03 ֪ͨÍæ¼ÒËÀÍöʱ¼ä #tagMCPlayerDeadTime

class  tagMCPlayerDeadTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DeadTime", c_int),    # ËÀÍöʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB1
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB1
        self.SubCmd = 0x03
        self.DeadTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerDeadTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 03 ֪ͨÍæ¼ÒËÀÍöʱ¼ä //tagMCPlayerDeadTime:
                                Cmd:%s,
                                SubCmd:%s,
                                DeadTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DeadTime
                                )
        return DumpString


m_NAtagMCPlayerDeadTime=tagMCPlayerDeadTime()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerDeadTime.Cmd,m_NAtagMCPlayerDeadTime.SubCmd))] = m_NAtagMCPlayerDeadTime


#------------------------------------------------------
# B1 07 Íæ¼ÒµãÊýÐÅÏ¢ #tagMCRolePointInfo

class  tagMCRolePointInfo(Structure):
    Head = tagHead()
    PointAttrIDCount = 0    #(BYTE PointAttrIDCount)// µãÀàÐ͸öÊý
    PointAttrIDList = list()    #(vector<BYTE> PointAttrIDList)// µãÀàÐÍÁбí
    PointValueList = list()    #(vector<DWORD> PointValueList)// µãÀàÐͶÔÓ¦ÒѼÓ×ÔÓɵãÊýÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x07
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PointAttrIDCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PointAttrIDCount):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.PointAttrIDList.append(value)
        for i in range(self.PointAttrIDCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.PointValueList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x07
        self.PointAttrIDCount = 0
        self.PointAttrIDList = list()
        self.PointValueList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1 * self.PointAttrIDCount
        length += 4 * self.PointAttrIDCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PointAttrIDCount)
        for i in range(self.PointAttrIDCount):
            data = CommFunc.WriteBYTE(data, self.PointAttrIDList[i])
        for i in range(self.PointAttrIDCount):
            data = CommFunc.WriteDWORD(data, self.PointValueList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PointAttrIDCount:%d,
                                PointAttrIDList:%s,
                                PointValueList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PointAttrIDCount,
                                "...",
                                "..."
                                )
        return DumpString


m_NAtagMCRolePointInfo=tagMCRolePointInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRolePointInfo.Head.Cmd,m_NAtagMCRolePointInfo.Head.SubCmd))] = m_NAtagMCRolePointInfo


#------------------------------------------------------
# B1 01 Íæ¼Ò¼¼ÄÜÁ¬»÷֪ͨ #tagMCSkillCombo

class  tagMCSkillCombo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ComboNum", c_ubyte),    # Á¬»÷¼¼ÄÜ×é±àºÅ
                  ("ComboCnt", c_ubyte),    # Á¬»÷Êý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB1
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB1
        self.SubCmd = 0x01
        self.ComboNum = 0
        self.ComboCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCSkillCombo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 01 Íæ¼Ò¼¼ÄÜÁ¬»÷֪ͨ //tagMCSkillCombo:
                                Cmd:%s,
                                SubCmd:%s,
                                ComboNum:%d,
                                ComboCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ComboNum,
                                self.ComboCnt
                                )
        return DumpString


m_NAtagMCSkillCombo=tagMCSkillCombo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSkillCombo.Cmd,m_NAtagMCSkillCombo.SubCmd))] = m_NAtagMCSkillCombo


#------------------------------------------------------
# B1 04 ¾çÇéÈÎÎñ״̬ #tagMCStoryMissionStateInfo

class  tagMCStoryMissionState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("StoryNum", c_ubyte),    #¾çÇé±àºÅ
                  ("IsAllFinish", c_ubyte),    #¸Ã¾çÇéÈÎÎñÊÇ·ñÈ«²¿Íê³É
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.StoryNum = 0
        self.IsAllFinish = 0
        return

    def GetLength(self):
        return sizeof(tagMCStoryMissionState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 04 ¾çÇéÈÎÎñ״̬ //tagMCStoryMissionStateInfo:
                                StoryNum:%d,
                                IsAllFinish:%d
                                '''\
                                %(
                                self.StoryNum,
                                self.IsAllFinish
                                )
        return DumpString


class  tagMCStoryMissionStateInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)// ¸öÊý
    StoryMissionStateList = list()    #(vector<tagMCStoryMissionState> StoryMissionStateList)// ¾çÇé״̬Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temStoryMissionStateList = tagMCStoryMissionState()
            _pos = temStoryMissionStateList.ReadData(_lpData, _pos)
            self.StoryMissionStateList.append(temStoryMissionStateList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x04
        self.Count = 0
        self.StoryMissionStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.StoryMissionStateList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.StoryMissionStateList[i].GetLength(), self.StoryMissionStateList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                StoryMissionStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCStoryMissionStateInfo=tagMCStoryMissionStateInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCStoryMissionStateInfo.Head.Cmd,m_NAtagMCStoryMissionStateInfo.Head.SubCmd))] = m_NAtagMCStoryMissionStateInfo


#------------------------------------------------------
#B1 05 ·À³ÁÃÔ #tagMCPlayerWallow

class  tagMCPlayerWallow(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Open", c_ubyte),    #  0 ¹Ø 1¿ª
                  ("OnlineTime", c_int),    #  ÔÚÏßʱ¼ä
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB1
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB1
        self.SubCmd = 0x05
        self.Open = 0
        self.OnlineTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCPlayerWallow)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B1 05 ·À³ÁÃÔ //tagMCPlayerWallow:
                                Cmd:%s,
                                SubCmd:%s,
                                Open:%d,
                                OnlineTime:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Open,
                                self.OnlineTime
                                )
        return DumpString


m_NAtagMCPlayerWallow=tagMCPlayerWallow()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerWallow.Cmd,m_NAtagMCPlayerWallow.SubCmd))] = m_NAtagMCPlayerWallow


#------------------------------------------------------
#B1 08 ¿ªÊ¼Ó¡¼ÇÁ÷ʧʱ¼ä #tagMCYinjiStartTime

class  tagMCYinjiStartTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB1
        self.SubCmd = 0x08
        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 = 0xB1
        self.SubCmd = 0x08
        return

    def GetLength(self):
        return sizeof(tagMCYinjiStartTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B1 08 ¿ªÊ¼Ó¡¼ÇÁ÷ʧʱ¼ä //tagMCYinjiStartTime:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


m_NAtagMCYinjiStartTime=tagMCYinjiStartTime()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCYinjiStartTime.Cmd,m_NAtagMCYinjiStartTime.SubCmd))] = m_NAtagMCYinjiStartTime


#------------------------------------------------------
# B1 15 ÌìµÀÊ÷ÐÅÏ¢ #tagMCTiandaoTreeInfo

class  tagMCTiandaoTreeInfo(Structure):
    Head = tagHead()
    Qiyun = 0    #(DWORD Qiyun)// µ±Ç°ÆøÔËÖµ
    AwardCount = 0    #(BYTE AwardCount)// ÌìµÀ¹ûÁìÈ¡¼Ç¼ֵ¸öÊý
    AwardStateList = list()    #(vector<DWORD> AwardStateList)// ÌìµÀ¹ûÁìÈ¡¼Ç¼ֵÁÐ±í£¬°´½±ÀøË÷Òýλ¶þ½øÖƼǼÊÇ·ñÒÑÁìÈ¡£¬Ò»¸öÖµ¿É´æ31룬ÈçÖµ1´æ0~30£¬Öµ2´æ31~61,...
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Qiyun,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AwardCount):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.AwardStateList.append(value)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x15
        self.Qiyun = 0
        self.AwardCount = 0
        self.AwardStateList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 4 * self.AwardCount

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.Qiyun)
        data = CommFunc.WriteBYTE(data, self.AwardCount)
        for i in range(self.AwardCount):
            data = CommFunc.WriteDWORD(data, self.AwardStateList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Qiyun:%d,
                                AwardCount:%d,
                                AwardStateList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Qiyun,
                                self.AwardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCTiandaoTreeInfo=tagMCTiandaoTreeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTiandaoTreeInfo.Head.Cmd,m_NAtagMCTiandaoTreeInfo.Head.SubCmd))] = m_NAtagMCTiandaoTreeInfo


#------------------------------------------------------
# B1 12 ÅàÑø¹¦Äܾ³½çÐÅÏ¢ #tagMCTrainRealmLVInfo

class  tagMCTrainRealmLV(Structure):
    _pack_ = 1
    _fields_ = [
                  ("FuncType", c_ubyte),    # ¹¦ÄÜÀàÐÍ£º1-×øÆ2-Áé³è£»3-ÁéÆ÷
                  ("TrainRealmLV", 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.FuncType = 0
        self.TrainRealmLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCTrainRealmLV)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 12 ÅàÑø¹¦Äܾ³½çÐÅÏ¢ //tagMCTrainRealmLVInfo:
                                FuncType:%d,
                                TrainRealmLV:%d
                                '''\
                                %(
                                self.FuncType,
                                self.TrainRealmLV
                                )
        return DumpString


class  tagMCTrainRealmLVInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    InfoList = list()    #(vector<tagMCTrainRealmLV> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x12
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCTrainRealmLV()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x12
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCTrainRealmLVInfo=tagMCTrainRealmLVInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTrainRealmLVInfo.Head.Cmd,m_NAtagMCTrainRealmLVInfo.Head.SubCmd))] = m_NAtagMCTrainRealmLVInfo


#------------------------------------------------------
# B1 16 ÀÛ¼ÆÏûºÄ»õ±ÒÐÅÏ¢ #tagMCUseMoneyTotalInfo

class  tagMCUseMoneyTotal(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MoneyType", c_ubyte),    # »õ±ÒÀàÐÍ£¬½öͬ²½ÐèÒª¼Ç¼µÄ»õ±ÒÀàÐÍ
                  ("UseTotal", 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.UseTotal = 0
        return

    def GetLength(self):
        return sizeof(tagMCUseMoneyTotal)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 16 ÀÛ¼ÆÏûºÄ»õ±ÒÐÅÏ¢ //tagMCUseMoneyTotalInfo:
                                MoneyType:%d,
                                UseTotal:%d
                                '''\
                                %(
                                self.MoneyType,
                                self.UseTotal
                                )
        return DumpString


class  tagMCUseMoneyTotalInfo(Structure):
    Head = tagHead()
    Count = 0    #(BYTE Count)
    InfoList = list()    #(vector<tagMCUseMoneyTotal> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x16
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temInfoList = tagMCUseMoneyTotal()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x16
        self.Count = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Count):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCUseMoneyTotalInfo=tagMCUseMoneyTotalInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCUseMoneyTotalInfo.Head.Cmd,m_NAtagMCUseMoneyTotalInfo.Head.SubCmd))] = m_NAtagMCUseMoneyTotalInfo


#------------------------------------------------------
# B1 14 Ïɹ¬ÐÅÏ¢ #tagMCXiangongInfo

class  tagMCXiangong(Structure):
    _pack_ = 1
    _fields_ = [
                  ("XiangongID", c_ushort),    # Ïɹ¬ID
                  ("LikeStateToday", c_ubyte),    # ½ñÈÕÊÇ·ñÒѵãÔÞ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.XiangongID = 0
        self.LikeStateToday = 0
        return

    def GetLength(self):
        return sizeof(tagMCXiangong)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 14 Ïɹ¬ÐÅÏ¢ //tagMCXiangongInfo:
                                XiangongID:%d,
                                LikeStateToday:%d
                                '''\
                                %(
                                self.XiangongID,
                                self.LikeStateToday
                                )
        return DumpString


class  tagMCXiangongInfo(Structure):
    Head = tagHead()
    LikeStateToday = 0    #(BYTE LikeStateToday)// ½ñÈÕÊÇ·ñÒѵãÔÞ£¬Ö¸Ïɹ¬µÄÍâ²ãµãÔÞ£¬·Çij¸öÖ¸¶¨Ïɹ¬
    XiangongCount = 0    #(BYTE XiangongCount)
    XiangongList = list()    #(vector<tagMCXiangong> XiangongList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x14
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.LikeStateToday,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.XiangongCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.XiangongCount):
            temXiangongList = tagMCXiangong()
            _pos = temXiangongList.ReadData(_lpData, _pos)
            self.XiangongList.append(temXiangongList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x14
        self.LikeStateToday = 0
        self.XiangongCount = 0
        self.XiangongList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.XiangongCount):
            length += self.XiangongList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.LikeStateToday)
        data = CommFunc.WriteBYTE(data, self.XiangongCount)
        for i in range(self.XiangongCount):
            data = CommFunc.WriteString(data, self.XiangongList[i].GetLength(), self.XiangongList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                LikeStateToday:%d,
                                XiangongCount:%d,
                                XiangongList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.LikeStateToday,
                                self.XiangongCount,
                                "..."
                                )
        return DumpString


m_NAtagMCXiangongInfo=tagMCXiangongInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCXiangongInfo.Head.Cmd,m_NAtagMCXiangongInfo.Head.SubCmd))] = m_NAtagMCXiangongInfo


#------------------------------------------------------
# B1 20 Õ½ÁîÐÅÏ¢ #tagMCZhanlingInfo

class  tagMCZhanling(Structure):
    _pack_ = 1
    _fields_ = [
                  ("NeedValue", c_int),    # ½±ÀøËùÐèÖµ
                  ("FreeRewardState", c_ubyte),    # Ãâ·ÑÕ½Áî½±ÀøÊÇ·ñÒÑÁìÈ¡
                  ("ZLRewardState", c_ubyte),    # ÆÕͨսÁî½±ÀøÊÇ·ñÒÑÁìÈ¡
                  ("ZLRewardStateH", c_ubyte),    # ¸ß¼¶Õ½Áî½±ÀøÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.NeedValue = 0
        self.FreeRewardState = 0
        self.ZLRewardState = 0
        self.ZLRewardStateH = 0
        return

    def GetLength(self):
        return sizeof(tagMCZhanling)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B1 20 Õ½ÁîÐÅÏ¢ //tagMCZhanlingInfo:
                                NeedValue:%d,
                                FreeRewardState:%d,
                                ZLRewardState:%d,
                                ZLRewardStateH:%d
                                '''\
                                %(
                                self.NeedValue,
                                self.FreeRewardState,
                                self.ZLRewardState,
                                self.ZLRewardStateH
                                )
        return DumpString


class  tagMCZhanlingInfo(Structure):
    Head = tagHead()
    ZhanlingType = 0    #(BYTE ZhanlingType)// Õ½ÁîÀàÐÍ
    IsActivite = 0    #(BYTE IsActivite)// ÆÕͨսÁîÊÇ·ñÒѼ¤»î
    IsActiviteH = 0    #(BYTE IsActiviteH)// ¸ß¼¶Õ½ÁîÊÇ·ñÒѼ¤»î
    Value1 = 0    #(DWORD Value1)// Õ½Áî¶ÔÓ¦µÄ×Ô¶¨ÒåÖµ£¬¿ÉÑ¡£¬ÈçµÇ¼սÁî´ú±í¿ªÊ¼¼ÆËãÈÕÆÚʱ¼ä´Á
    RewardCount = 0    #(WORD RewardCount)
    RewardList = list()    #(vector<tagMCZhanling> RewardList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x20
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ZhanlingType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsActivite,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsActiviteH,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RewardCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RewardCount):
            temRewardList = tagMCZhanling()
            _pos = temRewardList.ReadData(_lpData, _pos)
            self.RewardList.append(temRewardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB1
        self.Head.SubCmd = 0x20
        self.ZhanlingType = 0
        self.IsActivite = 0
        self.IsActiviteH = 0
        self.Value1 = 0
        self.RewardCount = 0
        self.RewardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 1
        length += 4
        length += 2
        for i in range(self.RewardCount):
            length += self.RewardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.ZhanlingType)
        data = CommFunc.WriteBYTE(data, self.IsActivite)
        data = CommFunc.WriteBYTE(data, self.IsActiviteH)
        data = CommFunc.WriteDWORD(data, self.Value1)
        data = CommFunc.WriteWORD(data, self.RewardCount)
        for i in range(self.RewardCount):
            data = CommFunc.WriteString(data, self.RewardList[i].GetLength(), self.RewardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ZhanlingType:%d,
                                IsActivite:%d,
                                IsActiviteH:%d,
                                Value1:%d,
                                RewardCount:%d,
                                RewardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ZhanlingType,
                                self.IsActivite,
                                self.IsActiviteH,
                                self.Value1,
                                self.RewardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCZhanlingInfo=tagMCZhanlingInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCZhanlingInfo.Head.Cmd,m_NAtagMCZhanlingInfo.Head.SubCmd))] = m_NAtagMCZhanlingInfo


#------------------------------------------------------
# B2 08 »ñµÃÏÉÔµ±ÒÐÅÏ¢ #tagMCAddXianyuanCoinMsg

class  tagMCAddXianyuanCoinMsg(Structure):
    Head = tagHead()
    MapID = 0    #(DWORD MapID)
    FuncLineID = 0    #(BYTE FuncLineID)
    Relation = 0    #(BYTE Relation)// µ±Ê±µÄ¹Øϵ£º0-ÎÞ£¬1-ºÃÓÑ£¬2-ÃËÓÑ
    RelationCoinAdd = 0    #(BYTE RelationCoinAdd)// Éç½»¹Øϵ×ܼӳÉ
    XianyuanCoinAdd = 0    #(WORD XianyuanCoinAdd)// ʵ¼ÊÔö¼ÓµÄÏÉÔµ±Ò
    Reason = 0    #(BYTE Reason)//ÏÉÔµ±ÒΪ0ʱµÄÔ­Òò£º1-ÖúÕ½´ÎÊýÉÏÏÞ£»2-ÿÈÕ»ñµÃÉÏÏÞ
    CallPlayerID = 0    #(DWORD CallPlayerID)// ÖúÕ½µÄÍæ¼ÒID£¬ÓÐֵʱ´ú±íÕæʵÖúÕ½£¬Ã»ÓÐֵʱΪ×Ô¼º´òµÄ
    NameLen = 0    #(BYTE NameLen)
    CallPlayerName = ""    #(String CallPlayerName)// ÖúÕ½µÄÍæ¼ÒÃû£¬size = NameLen
    IsSweep = 0    #(BYTE IsSweep)// ÊÇ·ñɨµ´
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x08
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncLineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Relation,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RelationCoinAdd,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.XianyuanCoinAdd,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Reason,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CallPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CallPlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.IsSweep,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x08
        self.MapID = 0
        self.FuncLineID = 0
        self.Relation = 0
        self.RelationCoinAdd = 0
        self.XianyuanCoinAdd = 0
        self.Reason = 0
        self.CallPlayerID = 0
        self.NameLen = 0
        self.CallPlayerName = ""
        self.IsSweep = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 1
        length += 1
        length += 2
        length += 1
        length += 4
        length += 1
        length += len(self.CallPlayerName)
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteBYTE(data, self.FuncLineID)
        data = CommFunc.WriteBYTE(data, self.Relation)
        data = CommFunc.WriteBYTE(data, self.RelationCoinAdd)
        data = CommFunc.WriteWORD(data, self.XianyuanCoinAdd)
        data = CommFunc.WriteBYTE(data, self.Reason)
        data = CommFunc.WriteDWORD(data, self.CallPlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.CallPlayerName)
        data = CommFunc.WriteBYTE(data, self.IsSweep)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                MapID:%d,
                                FuncLineID:%d,
                                Relation:%d,
                                RelationCoinAdd:%d,
                                XianyuanCoinAdd:%d,
                                Reason:%d,
                                CallPlayerID:%d,
                                NameLen:%d,
                                CallPlayerName:%s,
                                IsSweep:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.MapID,
                                self.FuncLineID,
                                self.Relation,
                                self.RelationCoinAdd,
                                self.XianyuanCoinAdd,
                                self.Reason,
                                self.CallPlayerID,
                                self.NameLen,
                                self.CallPlayerName,
                                self.IsSweep
                                )
        return DumpString


m_NAtagMCAddXianyuanCoinMsg=tagMCAddXianyuanCoinMsg()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAddXianyuanCoinMsg.Head.Cmd,m_NAtagMCAddXianyuanCoinMsg.Head.SubCmd))] = m_NAtagMCAddXianyuanCoinMsg


#------------------------------------------------------
# B2 10 ÏÉÃËÁªÈüÍæ¼ÒÅÅÃûÐÅÏ¢ #tagMCFamilyWarBillboard

class  tagMCFamilyWarPlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PlayerNameLen = 0    #(BYTE PlayerNameLen)//Íæ¼ÒÃû³Æ
    PlayerName = ""    #(String PlayerName)//size = PlayerNameLen
    Faction = 0    #(BYTE Faction)//ÕóÓª
    CrystalCount = 0    #(BYTE CrystalCount)//Õ¼ÁìË®¾§Êý
    RandBuffCount = 0    #(BYTE RandBuffCount)//ÇÀ¶áËæ»úbuffÊý
    KillPlayerCount = 0    #(BYTE KillPlayerCount)//»÷ɱÊý
    FightTime = 0    #(WORD FightTime)// Õ½¶·Ê±³¤£¬µ¥Î»Ãë
    Point = 0    #(DWORD Point)// »ý·Ö
    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.PlayerNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.PlayerNameLen)
        self.Faction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CrystalCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RandBuffCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.KillPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FightTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Point,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerNameLen = 0
        self.PlayerName = ""
        self.Faction = 0
        self.CrystalCount = 0
        self.RandBuffCount = 0
        self.KillPlayerCount = 0
        self.FightTime = 0
        self.Point = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += len(self.PlayerName)
        length += 1
        length += 1
        length += 1
        length += 1
        length += 2
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.PlayerNameLen)
        data = CommFunc.WriteString(data, self.PlayerNameLen, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Faction)
        data = CommFunc.WriteBYTE(data, self.CrystalCount)
        data = CommFunc.WriteBYTE(data, self.RandBuffCount)
        data = CommFunc.WriteBYTE(data, self.KillPlayerCount)
        data = CommFunc.WriteWORD(data, self.FightTime)
        data = CommFunc.WriteDWORD(data, self.Point)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                PlayerNameLen:%d,
                                PlayerName:%s,
                                Faction:%d,
                                CrystalCount:%d,
                                RandBuffCount:%d,
                                KillPlayerCount:%d,
                                FightTime:%d,
                                Point:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.PlayerNameLen,
                                self.PlayerName,
                                self.Faction,
                                self.CrystalCount,
                                self.RandBuffCount,
                                self.KillPlayerCount,
                                self.FightTime,
                                self.Point
                                )
        return DumpString


class  tagMCFamilyWarBillboard(Structure):
    Head = tagHead()
    GroupID = 0    #(BYTE GroupID)// ÁªÈü×鼶±ð, 5-S,4-A,3-B,2-C,1-D
    WinFaction = 0    #(BYTE WinFaction)// »ñʤÏÉÃËÕóÓª£¬Îª0ʱ´ú±í·Ç½áËãÐÅÏ¢
    TotalFightTime = 0    #(WORD TotalFightTime)// ×ÜÕ½¶·Ê±³¤£¬µ¥Î»Ã룬½áËãÐÅϢʱ²ÅÓÐÖµ
    BillboardCount = 0    #(BYTE BillboardCount)
    FBBillboardPlayer = list()    #(vector<tagMCFamilyWarPlayer> FBBillboardPlayer)//size = BillboardCount
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x10
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.GroupID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.WinFaction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TotalFightTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BillboardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.BillboardCount):
            temFBBillboardPlayer = tagMCFamilyWarPlayer()
            _pos = temFBBillboardPlayer.ReadData(_lpData, _pos)
            self.FBBillboardPlayer.append(temFBBillboardPlayer)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x10
        self.GroupID = 0
        self.WinFaction = 0
        self.TotalFightTime = 0
        self.BillboardCount = 0
        self.FBBillboardPlayer = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        length += 2
        length += 1
        for i in range(self.BillboardCount):
            length += self.FBBillboardPlayer[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.GroupID)
        data = CommFunc.WriteBYTE(data, self.WinFaction)
        data = CommFunc.WriteWORD(data, self.TotalFightTime)
        data = CommFunc.WriteBYTE(data, self.BillboardCount)
        for i in range(self.BillboardCount):
            data = CommFunc.WriteString(data, self.FBBillboardPlayer[i].GetLength(), self.FBBillboardPlayer[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                GroupID:%d,
                                WinFaction:%d,
                                TotalFightTime:%d,
                                BillboardCount:%d,
                                FBBillboardPlayer:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.GroupID,
                                self.WinFaction,
                                self.TotalFightTime,
                                self.BillboardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCFamilyWarBillboard=tagMCFamilyWarBillboard()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyWarBillboard.Head.Cmd,m_NAtagMCFamilyWarBillboard.Head.SubCmd))] = m_NAtagMCFamilyWarBillboard


#------------------------------------------------------
# B2 15 ¸±±¾ÂòbuffÐÅϢ֪ͨ #tagMCFBBuyBuffInfo

class  tagMCFBBuyBuffTime(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MapID", c_int),    
                  ("MoneyCnt", c_ushort),    
                  ("BuyTime", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.MapID = 0
        self.MoneyCnt = 0
        self.BuyTime = 0
        return

    def GetLength(self):
        return sizeof(tagMCFBBuyBuffTime)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 15 ¸±±¾ÂòbuffÐÅϢ֪ͨ //tagMCFBBuyBuffInfo:
                                MapID:%d,
                                MoneyCnt:%d,
                                BuyTime:%d
                                '''\
                                %(
                                self.MapID,
                                self.MoneyCnt,
                                self.BuyTime
                                )
        return DumpString


class  tagMCFBBuyBuffInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)
    InfoList = list()    #(vector<tagMCFBBuyBuffTime> InfoList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCFBBuyBuffTime()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x15
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFBBuyBuffInfo=tagMCFBBuyBuffInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBBuyBuffInfo.Head.Cmd,m_NAtagMCFBBuyBuffInfo.Head.SubCmd))] = m_NAtagMCFBBuyBuffInfo


#------------------------------------------------------
# B2 09 ¸±±¾´ÎÊý»Ö¸´Ê£Óàʱ¼ä #tagMCFBCntRegainRemainTime

class  tagMCFBCntRegain(Structure):
    _pack_ = 1
    _fields_ = [
                  ("DataMapID", c_int),    # µØͼID
                  ("RemainTime", c_int),    # Ê£Óàʱ¼äÃë
                  ("RegainCnt", c_ubyte),    # ½ñÈÕÒѻָ´´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.DataMapID = 0
        self.RemainTime = 0
        self.RegainCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCFBCntRegain)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 09 ¸±±¾´ÎÊý»Ö¸´Ê£Óàʱ¼ä //tagMCFBCntRegainRemainTime:
                                DataMapID:%d,
                                RemainTime:%d,
                                RegainCnt:%d
                                '''\
                                %(
                                self.DataMapID,
                                self.RemainTime,
                                self.RegainCnt
                                )
        return DumpString


class  tagMCFBCntRegainRemainTime(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// ÐÅÏ¢Êý
    InfoList = list()    #(vector<tagMCFBCntRegain> InfoList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temInfoList = tagMCFBCntRegain()
            _pos = temInfoList.ReadData(_lpData, _pos)
            self.InfoList.append(temInfoList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x09
        self.Cnt = 0
        self.InfoList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.InfoList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                InfoList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCFBCntRegainRemainTime=tagMCFBCntRegainRemainTime()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBCntRegainRemainTime.Head.Cmd,m_NAtagMCFBCntRegainRemainTime.Head.SubCmd))] = m_NAtagMCFBCntRegainRemainTime


#------------------------------------------------------
# B2 01 ֪ͨ·âħ̳˫±¶»÷ɱ״̬ #tagMCFMTDoubleState

class  tagMCFMTDoubleState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsDouble", c_ubyte),    #ÊÇ·ñË«±¶
                  ("OldDouble", c_ubyte),    #ÊÇ·ñÔø¾­ÔÊÐíË«±¶
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x01
        self.IsDouble = 0
        self.OldDouble = 0
        return

    def GetLength(self):
        return sizeof(tagMCFMTDoubleState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 01 ֪ͨ·âħ̳˫±¶»÷ɱ״̬ //tagMCFMTDoubleState:
                                Cmd:%s,
                                SubCmd:%s,
                                IsDouble:%d,
                                OldDouble:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsDouble,
                                self.OldDouble
                                )
        return DumpString


m_NAtagMCFMTDoubleState=tagMCFMTDoubleState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFMTDoubleState.Cmd,m_NAtagMCFMTDoubleState.SubCmd))] = m_NAtagMCFMTDoubleState


#------------------------------------------------------
# B2 06 ÖúÕ½ÕÙ»½½á¹û #tagMCHelpBattleCallResult

class  tagMCHelpBattleCallResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjID", c_int),    # ÖúսʵÀýID
                  ("PlayerID", c_int),    # ÖúÕ½¾µÏñID,´óÓÚ1СÓÚ100´ú±í»úÆ÷ÈË,Èç¹ûÊÇ»úÆ÷ÈËÇ°¶Ë°´Ë³Ðò×Ô¼º¼Ç¼¶ÔӦʵÀýID´ú±íÒÑÕÙ»½
                  ("Job", c_ubyte),    # Ö°Òµ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x06
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x06
        self.ObjID = 0
        self.PlayerID = 0
        self.Job = 0
        return

    def GetLength(self):
        return sizeof(tagMCHelpBattleCallResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 06 ÖúÕ½ÕÙ»½½á¹û //tagMCHelpBattleCallResult:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjID:%d,
                                PlayerID:%d,
                                Job:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjID,
                                self.PlayerID,
                                self.Job
                                )
        return DumpString


m_NAtagMCHelpBattleCallResult=tagMCHelpBattleCallResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHelpBattleCallResult.Cmd,m_NAtagMCHelpBattleCallResult.SubCmd))] = m_NAtagMCHelpBattleCallResult


#------------------------------------------------------
# B2 05 ÖúÕ½µÇ¼Ç½á¹û #tagMCHelpBattleCheckInResult

class  tagMCHelpBattleCheckInResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("IsOK", c_ubyte),    #ÊÇ·ñ³É¹¦
                  ("IsLogin", c_ubyte),    #ÊÇ·ñµÇ¼ͬ²½ÒѵǼÇ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x05
        self.IsOK = 0
        self.IsLogin = 0
        return

    def GetLength(self):
        return sizeof(tagMCHelpBattleCheckInResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 05 ÖúÕ½µÇ¼Ç½á¹û //tagMCHelpBattleCheckInResult:
                                Cmd:%s,
                                SubCmd:%s,
                                IsOK:%d,
                                IsLogin:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.IsOK,
                                self.IsLogin
                                )
        return DumpString


m_NAtagMCHelpBattleCheckInResult=tagMCHelpBattleCheckInResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHelpBattleCheckInResult.Cmd,m_NAtagMCHelpBattleCheckInResult.SubCmd))] = m_NAtagMCHelpBattleCheckInResult


#------------------------------------------------------
# B2 07 ÖúÕ½»úÆ÷ÈËÁбí #tagMCHelpBattleList

class  tagMCHelpBattlePlayer(Structure):
    ObjID = 0    #(DWORD ObjID)// ʵÀýID, 0´ú±íδÕÙ»½
    PlayerID = 0    #(DWORD PlayerID)// ÖúÕ½¾µÏñID, ´óÓÚ1СÓÚ100´ú±í»úÆ÷ÈË,Èç¹ûÊÇ»úÆ÷ÈË£¬Ã»ÓÐÒÔÏÂÐÅÏ¢£¬Ïà¹ØÐÅÏ¢×Ô¼º¶ÁÅäÖÃ
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)// Íæ¼ÒÃû£¬size = NameLen
    LV = 0    #(WORD LV)// Íæ¼ÒµÈ¼¶
    Job = 0    #(BYTE Job)// Íæ¼ÒÖ°Òµ£¬ Èç¹ûÊÇ»úÆ÷ÈË£¬ÔòÖ°ÒµÓÐÖµ£¬·þÎñ¶Ë¿ØÖÆ
    RealmLV = 0    #(WORD RealmLV)// Íæ¼Ò¾³½çµÈ¼¶
    Face = 0    #(DWORD Face)//»ù±¾Á³ÐÍ
    FacePic = 0    #(DWORD FacePic)//Í·Ïñ¿ò
    FightPower = 0    #(DWORD FightPower)// Íæ¼ÒÕ½Á¦
    Relation = 0    #(BYTE Relation)// ¹Øϵ£º0-ÎÞ£¬1-ºÃÓÑ£¬2-ÃËÓÑ
    IsNeedGold = 0    #(BYTE IsNeedGold)// ÊÇ·ñÐèÒªÏÉÓñÕÙ»½
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Relation,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsNeedGold,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ObjID = 0
        self.PlayerID = 0
        self.NameLen = 0
        self.Name = ""
        self.LV = 0
        self.Job = 0
        self.RealmLV = 0
        self.Face = 0
        self.FacePic = 0
        self.FightPower = 0
        self.Relation = 0
        self.IsNeedGold = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 4
        length += 1
        length += len(self.Name)
        length += 2
        length += 1
        length += 2
        length += 4
        length += 4
        length += 4
        length += 1
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.Name)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteWORD(data, self.RealmLV)
        data = CommFunc.WriteDWORD(data, self.Face)
        data = CommFunc.WriteDWORD(data, self.FacePic)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteBYTE(data, self.Relation)
        data = CommFunc.WriteBYTE(data, self.IsNeedGold)
        return data

    def OutputString(self):
        DumpString = '''
                                ObjID:%d,
                                PlayerID:%d,
                                NameLen:%d,
                                Name:%s,
                                LV:%d,
                                Job:%d,
                                RealmLV:%d,
                                Face:%d,
                                FacePic:%d,
                                FightPower:%d,
                                Relation:%d,
                                IsNeedGold:%d
                                '''\
                                %(
                                self.ObjID,
                                self.PlayerID,
                                self.NameLen,
                                self.Name,
                                self.LV,
                                self.Job,
                                self.RealmLV,
                                self.Face,
                                self.FacePic,
                                self.FightPower,
                                self.Relation,
                                self.IsNeedGold
                                )
        return DumpString


class  tagMCHelpBattleList(Structure):
    Head = tagHead()
    RefreshCount = 0    #(BYTE RefreshCount)// ÒÑˢдÎÊý
    HelpCount = 0    #(BYTE HelpCount)// ÖúÕ½¸öÊý
    HelpPlayerList = list()    #(vector<tagMCHelpBattlePlayer> HelpPlayerList)// ÖúÕ½¾µÏñÐÅÏ¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x07
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RefreshCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HelpCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.HelpCount):
            temHelpPlayerList = tagMCHelpBattlePlayer()
            _pos = temHelpPlayerList.ReadData(_lpData, _pos)
            self.HelpPlayerList.append(temHelpPlayerList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x07
        self.RefreshCount = 0
        self.HelpCount = 0
        self.HelpPlayerList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1
        for i in range(self.HelpCount):
            length += self.HelpPlayerList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.RefreshCount)
        data = CommFunc.WriteBYTE(data, self.HelpCount)
        for i in range(self.HelpCount):
            data = CommFunc.WriteString(data, self.HelpPlayerList[i].GetLength(), self.HelpPlayerList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RefreshCount:%d,
                                HelpCount:%d,
                                HelpPlayerList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RefreshCount,
                                self.HelpCount,
                                "..."
                                )
        return DumpString


m_NAtagMCHelpBattleList=tagMCHelpBattleList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHelpBattleList.Head.Cmd,m_NAtagMCHelpBattleList.Head.SubCmd))] = m_NAtagMCHelpBattleList


#------------------------------------------------------
# B2 11 ÖúÕ½¼Ç¼Áбí #tagMCHelpBattleRecordList

class  tagMCHelpBattleRecord(Structure):
    CallPlayerID = 0    #(DWORD CallPlayerID)// ÑûÇëÖúÕ½µÄÍæ¼ÒID
    NameLen = 0    #(BYTE NameLen)
    CallPlayerName = ""    #(String CallPlayerName)// ÑûÇëÖúÕ½µÄÍæ¼ÒÃû£¬size = NameLen
    MapID = 0    #(DWORD MapID)
    FuncLineID = 0    #(BYTE FuncLineID)
    XianyuanCoinAdd = 0    #(WORD XianyuanCoinAdd)// Ôö¼ÓµÄÏÉÔµ±Ò£¬0´ú±íÒÑ´ïÉÏÏÞ
    Relation = 0    #(BYTE Relation)// µ±Ê±µÄ¹Øϵ£º0-ÎÞ£¬1-ºÃÓÑ£¬2-ÃËÓÑ
    VIPLV = 0    #(BYTE VIPLV)// µ±Ê±µÄVIPµÈ¼¶
    HelpTime = ""    #(char HelpTime[19])// Öúսʱ¼äyyyy-MM-dd hh:mm:ss
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.CallPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CallPlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncLineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.XianyuanCoinAdd,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Relation,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.VIPLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HelpTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
        return _pos

    def Clear(self):
        self.CallPlayerID = 0
        self.NameLen = 0
        self.CallPlayerName = ""
        self.MapID = 0
        self.FuncLineID = 0
        self.XianyuanCoinAdd = 0
        self.Relation = 0
        self.VIPLV = 0
        self.HelpTime = ""
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 1
        length += len(self.CallPlayerName)
        length += 4
        length += 1
        length += 2
        length += 1
        length += 1
        length += 19

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.CallPlayerID)
        data = CommFunc.WriteBYTE(data, self.NameLen)
        data = CommFunc.WriteString(data, self.NameLen, self.CallPlayerName)
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteBYTE(data, self.FuncLineID)
        data = CommFunc.WriteWORD(data, self.XianyuanCoinAdd)
        data = CommFunc.WriteBYTE(data, self.Relation)
        data = CommFunc.WriteBYTE(data, self.VIPLV)
        data = CommFunc.WriteString(data, 19, self.HelpTime)
        return data

    def OutputString(self):
        DumpString = '''
                                CallPlayerID:%d,
                                NameLen:%d,
                                CallPlayerName:%s,
                                MapID:%d,
                                FuncLineID:%d,
                                XianyuanCoinAdd:%d,
                                Relation:%d,
                                VIPLV:%d,
                                HelpTime:%s
                                '''\
                                %(
                                self.CallPlayerID,
                                self.NameLen,
                                self.CallPlayerName,
                                self.MapID,
                                self.FuncLineID,
                                self.XianyuanCoinAdd,
                                self.Relation,
                                self.VIPLV,
                                self.HelpTime
                                )
        return DumpString


class  tagMCHelpBattleRecordList(Structure):
    Head = tagHead()
    RecordCount = 0    #(WORD RecordCount)// ¼Ç¼Êý
    RecordList = list()    #(vector<tagMCHelpBattleRecord> RecordList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x11
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.RecordCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.RecordCount):
            temRecordList = tagMCHelpBattleRecord()
            _pos = temRecordList.ReadData(_lpData, _pos)
            self.RecordList.append(temRecordList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x11
        self.RecordCount = 0
        self.RecordList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.RecordCount):
            length += self.RecordList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.RecordCount)
        for i in range(self.RecordCount):
            data = CommFunc.WriteString(data, self.RecordList[i].GetLength(), self.RecordList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                RecordCount:%d,
                                RecordList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.RecordCount,
                                "..."
                                )
        return DumpString


m_NAtagMCHelpBattleRecordList=tagMCHelpBattleRecordList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHelpBattleRecordList.Head.Cmd,m_NAtagMCHelpBattleRecordList.Head.SubCmd))] = m_NAtagMCHelpBattleRecordList


#------------------------------------------------------
# B2 04 ±ù¾§¿óÂöÐÅϢ֪ͨ #tagMCIceLodeInfo

class  tagMCIceLodeInfo(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// ½ñÈÕÍæ·¨ÊýÁ¿
    LineList = list()    #(vector<BYTE> LineList)// Íæ·¨Áбí
    AwardRecord = 0    #(DWORD AwardRecord)// Áì½±¼Ç¼
    HasSweep = 0    #(BYTE HasSweep)// ÊÇ·ñÒÑɨµ´
    DayLV = 0    #(WORD DayLV)// ½ñÈյȼ¶
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
            self.LineList.append(value)
        self.AwardRecord,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HasSweep,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.DayLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x04
        self.Cnt = 0
        self.LineList = list()
        self.AwardRecord = 0
        self.HasSweep = 0
        self.DayLV = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += 1 * self.Cnt
        length += 4
        length += 1
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteBYTE(data, self.LineList[i])
        data = CommFunc.WriteDWORD(data, self.AwardRecord)
        data = CommFunc.WriteBYTE(data, self.HasSweep)
        data = CommFunc.WriteWORD(data, self.DayLV)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                LineList:%s,
                                AwardRecord:%d,
                                HasSweep:%d,
                                DayLV:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "...",
                                self.AwardRecord,
                                self.HasSweep,
                                self.DayLV
                                )
        return DumpString


m_NAtagMCIceLodeInfo=tagMCIceLodeInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCIceLodeInfo.Head.Cmd,m_NAtagMCIceLodeInfo.Head.SubCmd))] = m_NAtagMCIceLodeInfo


#------------------------------------------------------
# B2 03 ¹«¹²¸±±¾É¨µ´ÐÅÏ¢ #tagMCPubFBSweepData

class  tagMCPubFBSweep(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PubNum", c_ubyte),    # ¹«¹²×é±àºÅ
                  ("FBMapID", c_int),    # µ±Ç°É¨µ´µÄ¸±±¾µØͼID
                  ("LineID", c_ushort),    # lineID
                  ("SweepTime", c_int),    # ¿ªÊ¼É¨µ´µÄʱ¼ä
                  ("SweepCnt", c_ubyte),    # ɨµ´´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x03
        self.PubNum = 0
        self.FBMapID = 0
        self.LineID = 0
        self.SweepTime = 0
        self.SweepCnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCPubFBSweep)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 03 ¹«¹²¸±±¾É¨µ´ÐÅÏ¢ //tagMCPubFBSweepData:
                                Cmd:%s,
                                SubCmd:%s,
                                PubNum:%d,
                                FBMapID:%d,
                                LineID:%d,
                                SweepTime:%d,
                                SweepCnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PubNum,
                                self.FBMapID,
                                self.LineID,
                                self.SweepTime,
                                self.SweepCnt
                                )
        return DumpString


class  tagMCPubFBSweepData(Structure):
    Head = tagHead()
    Cnt = 0    #(BYTE Cnt)// ÐÅÏ¢Êý
    SweepDatList = list()    #(vector<tagMCPubFBSweep> SweepDatList)// ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temSweepDatList = tagMCPubFBSweep()
            _pos = temSweepDatList.ReadData(_lpData, _pos)
            self.SweepDatList.append(temSweepDatList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x03
        self.Cnt = 0
        self.SweepDatList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.Cnt):
            length += self.SweepDatList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.SweepDatList[i].GetLength(), self.SweepDatList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Cnt:%d,
                                SweepDatList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPubFBSweepData=tagMCPubFBSweepData()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPubFBSweepData.Head.Cmd,m_NAtagMCPubFBSweepData.Head.SubCmd))] = m_NAtagMCPubFBSweepData


#------------------------------------------------------
# B2 17 ¾³½çËþÐÅÏ¢ #tagMCRealmTowerInfo

class  tagMCRealmTowerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Floor", c_int),    # ÒÑͨ¹Ø²ã
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x17
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x17
        self.Floor = 0
        return

    def GetLength(self):
        return sizeof(tagMCRealmTowerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 17 ¾³½çËþÐÅÏ¢ //tagMCRealmTowerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                Floor:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Floor
                                )
        return DumpString


m_NAtagMCRealmTowerInfo=tagMCRealmTowerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRealmTowerInfo.Cmd,m_NAtagMCRealmTowerInfo.SubCmd))] = m_NAtagMCRealmTowerInfo


#------------------------------------------------------
# B2 13 ÌìÐÇËþͨ¹Ø²ãÊý #tagMCSkyTowerInfo

class  tagMCSkyTowerServerReward(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Floor", c_int),    # È«·þ½±Àø²ãID
                  ("ServerRewardRecord", 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.Floor = 0
        self.ServerRewardRecord = 0
        return

    def GetLength(self):
        return sizeof(tagMCSkyTowerServerReward)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 13 ÌìÐÇËþͨ¹Ø²ãÊý //tagMCSkyTowerInfo:
                                Floor:%d,
                                ServerRewardRecord:%d
                                '''\
                                %(
                                self.Floor,
                                self.ServerRewardRecord
                                )
        return DumpString


class  tagMCSkyTowerInfo(Structure):
    Head = tagHead()
    Floor = 0    #(DWORD Floor)// ÒÑͨ¹Ø²ã
    ServerRewardCount = 0    #(WORD ServerRewardCount)
    ServerRewardList = list()    #(vector<tagMCSkyTowerServerReward> ServerRewardList)// È«·þ½±ÀøÁìÈ¡¼Ç¼ÁÐ±í£¬Ï·¢µÄ²ã¼Ç¼Ìæ»»¸üм´¿É£¬Áì½±¼Ç¼ûÓб仯ʱ·þÎñ¶Ë²»»áÏ·¢
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Floor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ServerRewardCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.ServerRewardCount):
            temServerRewardList = tagMCSkyTowerServerReward()
            _pos = temServerRewardList.ReadData(_lpData, _pos)
            self.ServerRewardList.append(temServerRewardList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x13
        self.Floor = 0
        self.ServerRewardCount = 0
        self.ServerRewardList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        for i in range(self.ServerRewardCount):
            length += self.ServerRewardList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.Floor)
        data = CommFunc.WriteWORD(data, self.ServerRewardCount)
        for i in range(self.ServerRewardCount):
            data = CommFunc.WriteString(data, self.ServerRewardList[i].GetLength(), self.ServerRewardList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Floor:%d,
                                ServerRewardCount:%d,
                                ServerRewardList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Floor,
                                self.ServerRewardCount,
                                "..."
                                )
        return DumpString


m_NAtagMCSkyTowerInfo=tagMCSkyTowerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSkyTowerInfo.Head.Cmd,m_NAtagMCSkyTowerInfo.Head.SubCmd))] = m_NAtagMCSkyTowerInfo


#------------------------------------------------------
# B2 16 ¿ªÊ¼×Ô¶¨Ò峡¾°½á¹û #tagMCStartCustomSceneResult

class  tagMCStartCustomSceneResult(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MapID", c_int),    
                  ("FuncLineID", c_ushort),    
                  ("Result", c_ubyte),    #ÊÇ·ñÔÊÐí
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x16
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x16
        self.MapID = 0
        self.FuncLineID = 0
        self.Result = 0
        return

    def GetLength(self):
        return sizeof(tagMCStartCustomSceneResult)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 16 ¿ªÊ¼×Ô¶¨Ò峡¾°½á¹û //tagMCStartCustomSceneResult:
                                Cmd:%s,
                                SubCmd:%s,
                                MapID:%d,
                                FuncLineID:%d,
                                Result:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MapID,
                                self.FuncLineID,
                                self.Result
                                )
        return DumpString


m_NAtagMCStartCustomSceneResult=tagMCStartCustomSceneResult()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCStartCustomSceneResult.Cmd,m_NAtagMCStartCustomSceneResult.SubCmd))] = m_NAtagMCStartCustomSceneResult


#------------------------------------------------------
#B2 02 ÍÆËÍÌáÐÑÉèÖÃ֪ͨ #tagMCPushNotificationsSetting

class  tagMCPushNotificationsSetting(Structure):
    Head = tagHead()
    OnoffBit = 0    #(DWORD OnoffBit)// °´Î»Ô¼¶¨¿ª¹Ø
    TimeLen = 0    #(BYTE TimeLen)
    TimeStr = ""    #(String TimeStr)// ʱ¼ä×Ö·û´®  01:02-05:00
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x02
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.OnoffBit,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TimeLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,self.TimeLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB2
        self.Head.SubCmd = 0x02
        self.OnoffBit = 0
        self.TimeLen = 0
        self.TimeStr = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += len(self.TimeStr)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.OnoffBit)
        data = CommFunc.WriteBYTE(data, self.TimeLen)
        data = CommFunc.WriteString(data, self.TimeLen, self.TimeStr)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                OnoffBit:%d,
                                TimeLen:%d,
                                TimeStr:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.OnoffBit,
                                self.TimeLen,
                                self.TimeStr
                                )
        return DumpString


m_NAtagMCPushNotificationsSetting=tagMCPushNotificationsSetting()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPushNotificationsSetting.Head.Cmd,m_NAtagMCPushNotificationsSetting.Head.SubCmd))] = m_NAtagMCPushNotificationsSetting


#------------------------------------------------------
# B2 12 ÖïÏÉBOSSЭÖú´ÎÊý #tagMCZhuXianBossCnt

class  tagMCZhuXianBossCnt(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Cnt", c_ubyte),    # Ê£Óà¿ÉЭÖú´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB2
        self.SubCmd = 0x12
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB2
        self.SubCmd = 0x12
        self.Cnt = 0
        return

    def GetLength(self):
        return sizeof(tagMCZhuXianBossCnt)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B2 12 ÖïÏÉBOSSЭÖú´ÎÊý //tagMCZhuXianBossCnt:
                                Cmd:%s,
                                SubCmd:%s,
                                Cnt:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Cnt
                                )
        return DumpString


m_NAtagMCZhuXianBossCnt=tagMCZhuXianBossCnt()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCZhuXianBossCnt.Cmd,m_NAtagMCZhuXianBossCnt.SubCmd))] = m_NAtagMCZhuXianBossCnt


#------------------------------------------------------
# B3 30 ÇéÔµÏà¹ØÐÅÏ¢ #tagMCLoveInfo

class  tagMCLoveInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("EatCandyToday", c_int),    # ½ñÈÕÒѳÔϲÌÇ´ÎÊý£¬°üº¬Ãâ·Ñ¼°¸¶·ÑµÄËùÓдÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x30
        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 = 0xB3
        self.SubCmd = 0x30
        self.EatCandyToday = 0
        return

    def GetLength(self):
        return sizeof(tagMCLoveInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B3 30 ÇéÔµÏà¹ØÐÅÏ¢ //tagMCLoveInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                EatCandyToday:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.EatCandyToday
                                )
        return DumpString


m_NAtagMCLoveInfo=tagMCLoveInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLoveInfo.Cmd,m_NAtagMCLoveInfo.SubCmd))] = m_NAtagMCLoveInfo


#------------------------------------------------------
# B3 27 Çé½äÐÅÏ¢ #tagMCLoveRingInfo

class  tagMCLoveRingInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ClassLV", c_ubyte),    # ½×
                  ("StarLV", c_ubyte),    # ÐÇ
                  ("EatCount", c_int),    # ±¾ÐÇÒÑ´ãÁ¶µÀ¾ßÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        self.SubCmd = 0x27
        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 = 0xB3
        self.SubCmd = 0x27
        self.ClassLV = 0
        self.StarLV = 0
        self.EatCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCLoveRingInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B3 27 Çé½äÐÅÏ¢ //tagMCLoveRingInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                ClassLV:%d,
                                StarLV:%d,
                                EatCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ClassLV,
                                self.StarLV,
                                self.EatCount
                                )
        return DumpString


m_NAtagMCLoveRingInfo=tagMCLoveRingInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLoveRingInfo.Cmd,m_NAtagMCLoveRingInfo.SubCmd))] = m_NAtagMCLoveRingInfo


#------------------------------------------------------
# B3 29 Çé½ä½âËø³É¹¦ #tagMCLoveRingUnlockOK

class  tagMCLoveRingUnlockOK(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB3
        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 = 0xB3
        self.SubCmd = 0x29
        return

    def GetLength(self):
        return sizeof(tagMCLoveRingUnlockOK)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B3 29 Çé½ä½âËø³É¹¦ //tagMCLoveRingUnlockOK:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


m_NAtagMCLoveRingUnlockOK=tagMCLoveRingUnlockOK()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLoveRingUnlockOK.Cmd,m_NAtagMCLoveRingUnlockOK.SubCmd))] = m_NAtagMCLoveRingUnlockOK


#------------------------------------------------------
# B4 11 ÐÂÔö¶ñÒâ¹¥»÷Íæ¼Ò #tagMCAddMaliciousAtkPlayer

class  tagMCAddMaliciousAtkPlayer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AtkPlayerID", c_int),    #¶ñÒâ¹¥»÷µÄÍæ¼ÒID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x11
        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 = 0xB4
        self.SubCmd = 0x11
        self.AtkPlayerID = 0
        return

    def GetLength(self):
        return sizeof(tagMCAddMaliciousAtkPlayer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B4 11 ÐÂÔö¶ñÒâ¹¥»÷Íæ¼Ò //tagMCAddMaliciousAtkPlayer:
                                Cmd:%s,
                                SubCmd:%s,
                                AtkPlayerID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AtkPlayerID
                                )
        return DumpString


m_NAtagMCAddMaliciousAtkPlayer=tagMCAddMaliciousAtkPlayer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAddMaliciousAtkPlayer.Cmd,m_NAtagMCAddMaliciousAtkPlayer.SubCmd))] = m_NAtagMCAddMaliciousAtkPlayer


#------------------------------------------------------
# B4 15 BossÉËѪÅÅÐаñÐÅÏ¢ #tagMCBossHurtValueRankInfo

class  tagMCBossHurtValueAssist(Structure):
    PlayerID = 0    #(DWORD PlayerID)// ÖúÕ½Íæ¼ÒID
    PlayerName = ""    #(char PlayerName[33])
    HurtValue = 0    #(DWORD HurtValue)//²»³¬¹ýÒÚ²¿·Ö
    HurtValueEx = 0    #(DWORD HurtValueEx)//Ö§³Ö³¬¹ý20ÒÚ
    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.HurtValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HurtValueEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.PlayerName = ""
        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.PlayerName)
        data = CommFunc.WriteDWORD(data, self.HurtValue)
        data = CommFunc.WriteDWORD(data, self.HurtValueEx)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                PlayerName:%s,
                                HurtValue:%d,
                                HurtValueEx:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.PlayerName,
                                self.HurtValue,
                                self.HurtValueEx
                                )
        return DumpString


class  tagMCBossHurtValue(Structure):
    HurtType = 0    #(BYTE HurtType)// ÉËѪÀàÐÍ 1-Íæ¼Ò£¬2-¶ÓÎé
    HurtID = 0    #(DWORD HurtID)//Íæ¼ÒʱΪÍæ¼ÒID£¬¶ÓÎéʱΪ¶ÓÎéID
    HurtName = ""    #(char HurtName[33])// Ãû³Æ
    HurtValue = 0    #(DWORD HurtValue)//²»³¬¹ýÒÚ²¿·Ö
    HurtValueEx = 0    #(DWORD HurtValueEx)//Ö§³Ö³¬¹ý20ÒÚ
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.HurtType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HurtID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HurtName,_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.HurtType = 0
        self.HurtID = 0
        self.HurtName = ""
        self.HurtValue = 0
        self.HurtValueEx = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 33
        length += 4
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.HurtType)
        data = CommFunc.WriteDWORD(data, self.HurtID)
        data = CommFunc.WriteString(data, 33, self.HurtName)
        data = CommFunc.WriteDWORD(data, self.HurtValue)
        data = CommFunc.WriteDWORD(data, self.HurtValueEx)
        return data

    def OutputString(self):
        DumpString = '''
                                HurtType:%d,
                                HurtID:%d,
                                HurtName:%s,
                                HurtValue:%d,
                                HurtValueEx:%d
                                '''\
                                %(
                                self.HurtType,
                                self.HurtID,
                                self.HurtName,
                                self.HurtValue,
                                self.HurtValueEx
                                )
        return DumpString


class  tagMCBossHurtValueRankInfo(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)//NPCʵÀýID
    HurtCount = 0    #(BYTE HurtCount)//ÉËѪÊýÄ¿
    HurtValueList = list()    #(vector<tagMCBossHurtValue> HurtValueList)
    AssistHurtCount = 0    #(BYTE AssistHurtCount)//ÖúÕ½ÉËѪÊýÄ¿
    AssistHurtValueList = list()    #(vector<tagMCBossHurtValueAssist> AssistHurtValueList)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x15
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HurtCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.HurtCount):
            temHurtValueList = tagMCBossHurtValue()
            _pos = temHurtValueList.ReadData(_lpData, _pos)
            self.HurtValueList.append(temHurtValueList)
        self.AssistHurtCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.AssistHurtCount):
            temAssistHurtValueList = tagMCBossHurtValueAssist()
            _pos = temAssistHurtValueList.ReadData(_lpData, _pos)
            self.AssistHurtValueList.append(temAssistHurtValueList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x15
        self.ObjID = 0
        self.HurtCount = 0
        self.HurtValueList = list()
        self.AssistHurtCount = 0
        self.AssistHurtValueList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        for i in range(self.HurtCount):
            length += self.HurtValueList[i].GetLength()
        length += 1
        for i in range(self.AssistHurtCount):
            length += self.AssistHurtValueList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteBYTE(data, self.HurtCount)
        for i in range(self.HurtCount):
            data = CommFunc.WriteString(data, self.HurtValueList[i].GetLength(), self.HurtValueList[i].GetBuffer())
        data = CommFunc.WriteBYTE(data, self.AssistHurtCount)
        for i in range(self.AssistHurtCount):
            data = CommFunc.WriteString(data, self.AssistHurtValueList[i].GetLength(), self.AssistHurtValueList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                HurtCount:%d,
                                HurtValueList:%s,
                                AssistHurtCount:%d,
                                AssistHurtValueList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.HurtCount,
                                "...",
                                self.AssistHurtCount,
                                "..."
                                )
        return DumpString


m_NAtagMCBossHurtValueRankInfo=tagMCBossHurtValueRankInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCBossHurtValueRankInfo.Head.Cmd,m_NAtagMCBossHurtValueRankInfo.Head.SubCmd))] = m_NAtagMCBossHurtValueRankInfo


#------------------------------------------------------
# B4 12 ɾ³ý¶ñÒâ¹¥»÷Íæ¼Ò #tagMCDelMaliciousAtkPlayer

class  tagMCDelMaliciousAtkPlayer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("AtkPlayerID", c_int),    #¶ñÒâ¹¥»÷µÄÍæ¼ÒID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x12
        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 = 0xB4
        self.SubCmd = 0x12
        self.AtkPlayerID = 0
        return

    def GetLength(self):
        return sizeof(tagMCDelMaliciousAtkPlayer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B4 12 ɾ³ý¶ñÒâ¹¥»÷Íæ¼Ò //tagMCDelMaliciousAtkPlayer:
                                Cmd:%s,
                                SubCmd:%s,
                                AtkPlayerID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.AtkPlayerID
                                )
        return DumpString


m_NAtagMCDelMaliciousAtkPlayer=tagMCDelMaliciousAtkPlayer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDelMaliciousAtkPlayer.Cmd,m_NAtagMCDelMaliciousAtkPlayer.SubCmd))] = m_NAtagMCDelMaliciousAtkPlayer


#------------------------------------------------------
# B4 04 NPC¼¼ÄÜÔ¤¾¯ #tagMCNPCSkillWarn

class  tagMCNPCSkillWarnPos(Structure):
    _pack_ = 1
    _fields_ = [
                  ("PosX", c_ushort),    
                  ("PosY", 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.PosX = 0
        self.PosY = 0
        return

    def GetLength(self):
        return sizeof(tagMCNPCSkillWarnPos)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B4 04 NPC¼¼ÄÜÔ¤¾¯ //tagMCNPCSkillWarn:
                                PosX:%d,
                                PosY:%d
                                '''\
                                %(
                                self.PosX,
                                self.PosY
                                )
        return DumpString


class  tagMCNPCSkillWarn(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    NPCID = 0    #(DWORD NPCID)
    SkillID = 0    #(DWORD SkillID)
    WarnTime = 0    #(WORD WarnTime)// Ô¤¾¯×Üʱ¼ä
    RemainTime = 0    #(WORD RemainTime)// Ê£Óàʱ¼ä
    WarnPosCnt = 0    #(BYTE WarnPosCnt)
    WarnPosList = list()    #(vector<tagMCNPCSkillWarnPos> WarnPosList)// Ô¤¾¯µã×ø±êÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x04
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SkillID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WarnTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.RemainTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.WarnPosCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.WarnPosCnt):
            temWarnPosList = tagMCNPCSkillWarnPos()
            _pos = temWarnPosList.ReadData(_lpData, _pos)
            self.WarnPosList.append(temWarnPosList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x04
        self.ObjID = 0
        self.NPCID = 0
        self.SkillID = 0
        self.WarnTime = 0
        self.RemainTime = 0
        self.WarnPosCnt = 0
        self.WarnPosList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 2
        length += 2
        length += 1
        for i in range(self.WarnPosCnt):
            length += self.WarnPosList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteDWORD(data, self.SkillID)
        data = CommFunc.WriteWORD(data, self.WarnTime)
        data = CommFunc.WriteWORD(data, self.RemainTime)
        data = CommFunc.WriteBYTE(data, self.WarnPosCnt)
        for i in range(self.WarnPosCnt):
            data = CommFunc.WriteString(data, self.WarnPosList[i].GetLength(), self.WarnPosList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                NPCID:%d,
                                SkillID:%d,
                                WarnTime:%d,
                                RemainTime:%d,
                                WarnPosCnt:%d,
                                WarnPosList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.NPCID,
                                self.SkillID,
                                self.WarnTime,
                                self.RemainTime,
                                self.WarnPosCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCNPCSkillWarn=tagMCNPCSkillWarn()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCSkillWarn.Head.Cmd,m_NAtagMCNPCSkillWarn.Head.SubCmd))] = m_NAtagMCNPCSkillWarn


#------------------------------------------------------
#B4 05 »ñµÃ¾­Ñé #tagMCAddExp

class  tagMCAddExp(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ExpPoint", c_int),    # µ¥Î»ÒÚµã
                  ("Exp", c_int),    # µ¥Î»µã
                  ("Source", c_ubyte),    #¾­Ñé»ñÈ¡À´Ô´
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB4
        self.SubCmd = 0x05
        self.ExpPoint = 0
        self.Exp = 0
        self.Source = 0
        return

    def GetLength(self):
        return sizeof(tagMCAddExp)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 05 »ñµÃ¾­Ñé //tagMCAddExp:
                                Cmd:%s,
                                SubCmd:%s,
                                ExpPoint:%d,
                                Exp:%d,
                                Source:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ExpPoint,
                                self.Exp,
                                self.Source
                                )
        return DumpString


m_NAtagMCAddExp=tagMCAddExp()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAddExp.Cmd,m_NAtagMCAddExp.SubCmd))] = m_NAtagMCAddExp


#------------------------------------------------------
#B4 03 ¼¼Äܹ¥»÷ʧ°Ü  #tagMCAttackFail

class  tagMCAttackFail(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("SkillID", c_int),    #¼¼ÄÜID
                  ("Reason", c_ubyte),    #Ô­Òò ĬÈÏ0
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x03
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB4
        self.SubCmd = 0x03
        self.SkillID = 0
        self.Reason = 0
        return

    def GetLength(self):
        return sizeof(tagMCAttackFail)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 03 ¼¼Äܹ¥»÷ʧ°Ü  //tagMCAttackFail:
                                Cmd:%s,
                                SubCmd:%s,
                                SkillID:%d,
                                Reason:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.SkillID,
                                self.Reason
                                )
        return DumpString


m_NAtagMCAttackFail=tagMCAttackFail()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCAttackFail.Cmd,m_NAtagMCAttackFail.SubCmd))] = m_NAtagMCAttackFail


#------------------------------------------------------
#B4 14 ¸ù¾ÝÀàÐÍÀ´¾ö¶¨Òƶ¯µÄ·½Ê½ #tagMCMoveByType

class  tagMCMoveByType(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ID", c_int),    #Íæ¼ÒID
                  ("PosX", c_ushort),    # Ä¿±êX
                  ("PosY", c_ushort),    # Ä¿±êY
                  ("MoveType", c_ubyte),    #Òƶ¯·½Ê½
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x14
        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 = 0xB4
        self.SubCmd = 0x14
        self.ID = 0
        self.PosX = 0
        self.PosY = 0
        self.MoveType = 0
        return

    def GetLength(self):
        return sizeof(tagMCMoveByType)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 14 ¸ù¾ÝÀàÐÍÀ´¾ö¶¨Òƶ¯µÄ·½Ê½ //tagMCMoveByType:
                                Cmd:%s,
                                SubCmd:%s,
                                ID:%d,
                                PosX:%d,
                                PosY:%d,
                                MoveType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ID,
                                self.PosX,
                                self.PosY,
                                self.MoveType
                                )
        return DumpString


m_NAtagMCMoveByType=tagMCMoveByType()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMoveByType.Cmd,m_NAtagMCMoveByType.SubCmd))] = m_NAtagMCMoveByType


#------------------------------------------------------
#B4 07 ±»¶¯¼¼ÄÜҳѡÔñ£¨¹¦·¨£© # tagMCPassivePage

class  tagMCPassivePage(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Page", c_ubyte),    # ·ÖÒ³
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x07
        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 = 0xB4
        self.SubCmd = 0x07
        self.Page = 0
        return

    def GetLength(self):
        return sizeof(tagMCPassivePage)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 07 ±»¶¯¼¼ÄÜҳѡÔñ£¨¹¦·¨£© // tagMCPassivePage:
                                Cmd:%s,
                                SubCmd:%s,
                                Page:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Page
                                )
        return DumpString


m_NAtagMCPassivePage=tagMCPassivePage()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPassivePage.Cmd,m_NAtagMCPassivePage.SubCmd))] = m_NAtagMCPassivePage


#------------------------------------------------------
#B4 06 ±»¶¯¼¼ÄÜÉèÖÃ֪ͨ(¹¦·¨) # tagMCPassiveSet

class  tagMCPassiveSkills(Structure):
    Count = 0    #(BYTE Count)
    SkillIDList = list()    #(vector<DWORD> SkillIDList)
    data = None

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.SkillIDList.append(value)
        return _pos

    def Clear(self):
        self.Count = 0
        self.SkillIDList = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4 * self.Count

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteDWORD(data, self.SkillIDList[i])
        return data

    def OutputString(self):
        DumpString = '''
                                Count:%d,
                                SkillIDList:%s
                                '''\
                                %(
                                self.Count,
                                "..."
                                )
        return DumpString


class  tagMCPassiveSet(Structure):
    Head = tagHead()
    PageCnt = 0    #(BYTE PageCnt)// ·ÖÒ³
    PassiveSkills = list()    #(vector<tagMCPassiveSkills> PassiveSkills)// ±»¶¯¼¼ÄÜÁбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x06
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PageCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.PageCnt):
            temPassiveSkills = tagMCPassiveSkills()
            _pos = temPassiveSkills.ReadData(_lpData, _pos)
            self.PassiveSkills.append(temPassiveSkills)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x06
        self.PageCnt = 0
        self.PassiveSkills = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        for i in range(self.PageCnt):
            length += self.PassiveSkills[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteBYTE(data, self.PageCnt)
        for i in range(self.PageCnt):
            data = CommFunc.WriteString(data, self.PassiveSkills[i].GetLength(), self.PassiveSkills[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PageCnt:%d,
                                PassiveSkills:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PageCnt,
                                "..."
                                )
        return DumpString


m_NAtagMCPassiveSet=tagMCPassiveSet()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPassiveSet.Head.Cmd,m_NAtagMCPassiveSet.Head.SubCmd))] = m_NAtagMCPassiveSet


#------------------------------------------------------
#B4 08 ±»¶¯¼¼Äܹ¦·¨ÉèÖóɹ¦»Ø¸´ # tagMCPassiveSetAnswer

class  tagMCPassiveSetAnswer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Page", c_ubyte),    # ·ÖÒ³
                  ("Index", c_ubyte),    # ÐòºÅ
                  ("SkillID", c_int),    # ¼¼ÄÜID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x08
        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 = 0xB4
        self.SubCmd = 0x08
        self.Page = 0
        self.Index = 0
        self.SkillID = 0
        return

    def GetLength(self):
        return sizeof(tagMCPassiveSetAnswer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 08 ±»¶¯¼¼Äܹ¦·¨ÉèÖóɹ¦»Ø¸´ // tagMCPassiveSetAnswer:
                                Cmd:%s,
                                SubCmd:%s,
                                Page:%d,
                                Index:%d,
                                SkillID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Page,
                                self.Index,
                                self.SkillID
                                )
        return DumpString


m_NAtagMCPassiveSetAnswer=tagMCPassiveSetAnswer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPassiveSetAnswer.Cmd,m_NAtagMCPassiveSetAnswer.SubCmd))] = m_NAtagMCPassiveSetAnswer


#------------------------------------------------------
# B4 13 ֪ͨÍæ¼ÒËùÓÐÒÑѧ¼¼ÄÜ #tagMCPlayerSkills

class  tagPlayerSkill(Structure):
    _pack_ = 1
    _fields_ = [
                  ("SkillID", c_int),    #¼¼ÄÜID
                  ("RemainTime", c_int),    #Ê£Óàʱ¼ä
                  ("Proficiency", 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.SkillID = 0
        self.RemainTime = 0
        self.Proficiency = 0
        return

    def GetLength(self):
        return sizeof(tagPlayerSkill)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// B4 13 ֪ͨÍæ¼ÒËùÓÐÒÑѧ¼¼ÄÜ //tagMCPlayerSkills:
                                SkillID:%d,
                                RemainTime:%d,
                                Proficiency:%d
                                '''\
                                %(
                                self.SkillID,
                                self.RemainTime,
                                self.Proficiency
                                )
        return DumpString


class  tagMCPlayerSkills(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)//¼¼ÄܸöÊý
    Skills = list()    #(vector<tagPlayerSkill> Skills)// ¼¼ÄÜÊý¾Ý
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x13
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temSkills = tagPlayerSkill()
            _pos = temSkills.ReadData(_lpData, _pos)
            self.Skills.append(temSkills)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x13
        self.Count = 0
        self.Skills = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.Skills[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.Skills[i].GetLength(), self.Skills[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                Skills:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCPlayerSkills=tagMCPlayerSkills()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerSkills.Head.Cmd,m_NAtagMCPlayerSkills.Head.SubCmd))] = m_NAtagMCPlayerSkills


#------------------------------------------------------
#B4 0A Íæ¼ÒÒƶ¯ #tagMCPYPlayerMove

class  tagMCPYPlayerMove(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Dir", c_ushort),    # ³¯Ïò
                  ("ClientPosX", c_ushort),    # ¿Í»§¶Ë×ø±êX ºÁÃ×
                  ("ClientPosY", c_ushort),    # ¿Í»§¶Ë×ø±êY
                  ("SeverPosX", c_ushort),    # ·þÎñ¶Ë×ø±êX ¸ñ×Ó
                  ("SeverPosY", c_ushort),    # ·þÎñ¶Ë×ø±êY
                  ("ObjID", c_int),    
                  ("ObjType", c_ubyte),    
                  ("Speed", c_ushort),    
                  ("MoveType", c_ubyte),    # 0 Í£Ö¹ 1Òƶ¯
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x0A
        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 = 0xB4
        self.SubCmd = 0x0A
        self.Dir = 0
        self.ClientPosX = 0
        self.ClientPosY = 0
        self.SeverPosX = 0
        self.SeverPosY = 0
        self.ObjID = 0
        self.ObjType = 0
        self.Speed = 0
        self.MoveType = 0
        return

    def GetLength(self):
        return sizeof(tagMCPYPlayerMove)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 0A Íæ¼ÒÒƶ¯ //tagMCPYPlayerMove:
                                Cmd:%s,
                                SubCmd:%s,
                                Dir:%d,
                                ClientPosX:%d,
                                ClientPosY:%d,
                                SeverPosX:%d,
                                SeverPosY:%d,
                                ObjID:%d,
                                ObjType:%d,
                                Speed:%d,
                                MoveType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Dir,
                                self.ClientPosX,
                                self.ClientPosY,
                                self.SeverPosX,
                                self.SeverPosY,
                                self.ObjID,
                                self.ObjType,
                                self.Speed,
                                self.MoveType
                                )
        return DumpString


m_NAtagMCPYPlayerMove=tagMCPYPlayerMove()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPYPlayerMove.Cmd,m_NAtagMCPYPlayerMove.SubCmd))] = m_NAtagMCPYPlayerMove


#------------------------------------------------------
#B4 02 սǰ³å·æ¹ã²¥ #tagMCRush

class  tagMCRush(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ID", c_int),    #Íæ¼ÒID
                  ("PosX", c_ushort),    # Ä¿±êX
                  ("PosY", c_ushort),    # Ä¿±êY
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xB4
        self.SubCmd = 0x02
        self.ID = 0
        self.PosX = 0
        self.PosY = 0
        return

    def GetLength(self):
        return sizeof(tagMCRush)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 02 սǰ³å·æ¹ã²¥ //tagMCRush:
                                Cmd:%s,
                                SubCmd:%s,
                                ID:%d,
                                PosX:%d,
                                PosY:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ID,
                                self.PosX,
                                self.PosY
                                )
        return DumpString


m_NAtagMCRush=tagMCRush()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCRush.Cmd,m_NAtagMCRush.SubCmd))] = m_NAtagMCRush


#------------------------------------------------------
#B4 01 ¼¼ÄÜÉËѪ֪ͨ£¨·ÇÖ±½ÓÊͷż¼ÄÜ£© #tagMCSkillHurtList

class  tagSkillPosHurtObj(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ObjType", c_ubyte),    
                  ("ObjID", c_int),    
                  ("AttackType", c_ubyte),    #±¬»÷, miss
                  ("HurtHP", c_int),    
                  ("HurtHPEx", c_int),    
                  ("CurHP", c_int),    
                  ("CurHPEx", 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.ObjType = 0
        self.ObjID = 0
        self.AttackType = 0
        self.HurtHP = 0
        self.HurtHPEx = 0
        self.CurHP = 0
        self.CurHPEx = 0
        return

    def GetLength(self):
        return sizeof(tagSkillPosHurtObj)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 01 ¼¼ÄÜÉËѪ֪ͨ£¨·ÇÖ±½ÓÊͷż¼ÄÜ£© //tagMCSkillHurtList:
                                ObjType:%d,
                                ObjID:%d,
                                AttackType:%d,
                                HurtHP:%d,
                                HurtHPEx:%d,
                                CurHP:%d,
                                CurHPEx:%d
                                '''\
                                %(
                                self.ObjType,
                                self.ObjID,
                                self.AttackType,
                                self.HurtHP,
                                self.HurtHPEx,
                                self.CurHP,
                                self.CurHPEx
                                )
        return DumpString


class  tagMCSkillHurtList(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    ObjType = 0    #(BYTE ObjType)
    SkillID = 0    #(WORD SkillID)
    PosX = 0    #(WORD PosX)
    PosY = 0    #(WORD PosY)
    HurtCount = 0    #(WORD HurtCount)//É˺¦ÊýÄ¿
    HurtList = list()    #(vector<tagSkillPosHurtObj> HurtList)//size = HurtCount
    SkillElementID = 0    #(WORD SkillElementID)//ר¾«¼¼ÄÜID
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x01
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ObjType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SkillID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.HurtCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.HurtCount):
            temHurtList = tagSkillPosHurtObj()
            _pos = temHurtList.ReadData(_lpData, _pos)
            self.HurtList.append(temHurtList)
        self.SkillElementID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x01
        self.ObjID = 0
        self.ObjType = 0
        self.SkillID = 0
        self.PosX = 0
        self.PosY = 0
        self.HurtCount = 0
        self.HurtList = list()
        self.SkillElementID = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 2
        length += 2
        length += 2
        length += 2
        for i in range(self.HurtCount):
            length += self.HurtList[i].GetLength()
        length += 2

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteBYTE(data, self.ObjType)
        data = CommFunc.WriteWORD(data, self.SkillID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteWORD(data, self.HurtCount)
        for i in range(self.HurtCount):
            data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.SkillElementID)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                ObjType:%d,
                                SkillID:%d,
                                PosX:%d,
                                PosY:%d,
                                HurtCount:%d,
                                HurtList:%s,
                                SkillElementID:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.ObjType,
                                self.SkillID,
                                self.PosX,
                                self.PosY,
                                self.HurtCount,
                                "...",
                                self.SkillElementID
                                )
        return DumpString


m_NAtagMCSkillHurtList=tagMCSkillHurtList()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSkillHurtList.Head.Cmd,m_NAtagMCSkillHurtList.Head.SubCmd))] = m_NAtagMCSkillHurtList


#------------------------------------------------------
#B4 10 ÍÑ»ú¹Ò±»É±ºóÀëÏßÕÒ»Ø # tagMCTJGDeadPay

class  tagMCTJGDeadPay(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Times", c_int),    # ¿ÉÕÒ»Øʱ¼ä
                  ("DeadTime", c_int),    # ËÀÍöʱ¼ä
                  ("Exp", c_int),    # ¾­Ñé
                  ("Exp1", c_int),    # ¾­Ñé ÒÚ
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xB4
        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 = 0xB4
        self.SubCmd = 0x10
        self.Times = 0
        self.DeadTime = 0
        self.Exp = 0
        self.Exp1 = 0
        return

    def GetLength(self):
        return sizeof(tagMCTJGDeadPay)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 10 ÍÑ»ú¹Ò±»É±ºóÀëÏßÕÒ»Ø // tagMCTJGDeadPay:
                                Cmd:%s,
                                SubCmd:%s,
                                Times:%d,
                                DeadTime:%d,
                                Exp:%d,
                                Exp1:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Times,
                                self.DeadTime,
                                self.Exp,
                                self.Exp1
                                )
        return DumpString


m_NAtagMCTJGDeadPay=tagMCTJGDeadPay()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTJGDeadPay.Cmd,m_NAtagMCTJGDeadPay.SubCmd))] = m_NAtagMCTJGDeadPay


#------------------------------------------------------
#B4 09 ֪ͨÍÑ»ú¹Ò½á¹û #tagMCTJGInfo

class  tagMCTJGItems(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(tagMCTJGItems)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''//B4 09 ֪ͨÍÑ»ú¹Ò½á¹û //tagMCTJGInfo:
                                ItemID:%d,
                                Count:%d
                                '''\
                                %(
                                self.ItemID,
                                self.Count
                                )
        return DumpString


class  tagMCTJGInfo(Structure):
    Head = tagHead()
    Exp1 = 0    #(DWORD Exp1)// ¾­Ñé
    Exp2 = 0    #(DWORD Exp2)// ³¬ÒÚ¾­Ñé
    Times = 0    #(DWORD Times)// ʹÓÃʱ¼äÃë
    PurpleEquip = 0    #(WORD PurpleEquip)// ²ú³ö×Ï×°ÊýÁ¿
    OrangeEquip = 0    #(WORD OrangeEquip)// ²ú³ö³È×°ÊýÁ¿
    EatPurpleEquip = 0    #(WORD EatPurpleEquip)// ÍÌÊÉ×Ï×°ÊýÁ¿
    BeforeLV = 0    #(WORD BeforeLV)//ÍÑ»úÇ°¼Ç¼µÄµÈ¼¶
    GiveCnt = 0    #(WORD GiveCnt)//»ñµÃÁ¶µ¤²ÄÁÏÊýÁ¿
    Cnt = 0    #(BYTE Cnt)//ÎïÆ·Àà±ðÊýÁ¿
    Items = list()    #(vector<tagMCTJGItems> Items)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x09
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Exp1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Exp2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Times,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PurpleEquip,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OrangeEquip,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.EatPurpleEquip,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BeforeLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.GiveCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Cnt):
            temItems = tagMCTJGItems()
            _pos = temItems.ReadData(_lpData, _pos)
            self.Items.append(temItems)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x09
        self.Exp1 = 0
        self.Exp2 = 0
        self.Times = 0
        self.PurpleEquip = 0
        self.OrangeEquip = 0
        self.EatPurpleEquip = 0
        self.BeforeLV = 0
        self.GiveCnt = 0
        self.Cnt = 0
        self.Items = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 4
        length += 4
        length += 2
        length += 2
        length += 2
        length += 2
        length += 2
        length += 1
        for i in range(self.Cnt):
            length += self.Items[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.Exp1)
        data = CommFunc.WriteDWORD(data, self.Exp2)
        data = CommFunc.WriteDWORD(data, self.Times)
        data = CommFunc.WriteWORD(data, self.PurpleEquip)
        data = CommFunc.WriteWORD(data, self.OrangeEquip)
        data = CommFunc.WriteWORD(data, self.EatPurpleEquip)
        data = CommFunc.WriteWORD(data, self.BeforeLV)
        data = CommFunc.WriteWORD(data, self.GiveCnt)
        data = CommFunc.WriteBYTE(data, self.Cnt)
        for i in range(self.Cnt):
            data = CommFunc.WriteString(data, self.Items[i].GetLength(), self.Items[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Exp1:%d,
                                Exp2:%d,
                                Times:%d,
                                PurpleEquip:%d,
                                OrangeEquip:%d,
                                EatPurpleEquip:%d,
                                BeforeLV:%d,
                                GiveCnt:%d,
                                Cnt:%d,
                                Items:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Exp1,
                                self.Exp2,
                                self.Times,
                                self.PurpleEquip,
                                self.OrangeEquip,
                                self.EatPurpleEquip,
                                self.BeforeLV,
                                self.GiveCnt,
                                self.Cnt,
                                "..."
                                )
        return DumpString


m_NAtagMCTJGInfo=tagMCTJGInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTJGInfo.Head.Cmd,m_NAtagMCTJGInfo.Head.SubCmd))] = m_NAtagMCTJGInfo


#------------------------------------------------------
# B4 20 »ØºÏÖÆÕ½¶·×´Ì¬ #tagMCTurnFightState

class  tagMCTurnFightState(Structure):
    Head = tagHead()
    MapID = 0    #(DWORD MapID)// ×Ô¶¨ÒåµØͼID£¬¿ÉÓÃÓÚ°ó¶¨Õ½¶·³¡¾°¹¦ÄÜ£¨ÈçÒ°Íâ¹Ø¿¨£¬ÅÀËþ¹¦ÄÜ£¬¾º¼¼³¡µÈ£©
    FuncLineID = 0    #(WORD FuncLineID)
    TagType = 0    #(BYTE TagType)// Õ½¶·Ä¿±êÀàÐÍ£¬0-NPC£¬1-Íæ¼Ò£¬2-¶ÓÎé
    TagID = 0    #(DWORD TagID)// Õ½¶·Ä¿±êÀàÐͶÔÓ¦µÄID
    State = 0    #(BYTE State)// 0-Æðʼ״̬±ê¼Ç£»1-×¼±¸Íê±Ï£»2-Õ½¶·ÖУ»3-Õ½¶·½áÊø£»4-½áËã½±Àø£»5-½áÊø״̬±ê¼Ç
    TurnNum = 0    #(BYTE TurnNum)// µ±Ç°ÂÖ´Î
    TurnMax = 0    #(BYTE TurnMax)// ×î´óÂÖ´Î
    Len = 0    #(WORD Len)
    Msg = ""    #(String Msg)//size = Len
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x20
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FuncLineID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TagType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TagID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.State,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TurnNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.TurnMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Msg,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xB4
        self.Head.SubCmd = 0x20
        self.MapID = 0
        self.FuncLineID = 0
        self.TagType = 0
        self.TagID = 0
        self.State = 0
        self.TurnNum = 0
        self.TurnMax = 0
        self.Len = 0
        self.Msg = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 1
        length += 4
        length += 1
        length += 1
        length += 1
        length += 2
        length += len(self.Msg)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.MapID)
        data = CommFunc.WriteWORD(data, self.FuncLineID)
        data = CommFunc.WriteBYTE(data, self.TagType)
        data = CommFunc.WriteDWORD(data, self.TagID)
        data = CommFunc.WriteBYTE(data, self.State)
        data = CommFunc.WriteBYTE(data, self.TurnNum)
        data = CommFunc.WriteBYTE(data, self.TurnMax)
        data = CommFunc.WriteWORD(data, self.Len)
        data = CommFunc.WriteString(data, self.Len, self.Msg)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                MapID:%d,
                                FuncLineID:%d,
                                TagType:%d,
                                TagID:%d,
                                State:%d,
                                TurnNum:%d,
                                TurnMax:%d,
                                Len:%d,
                                Msg:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.MapID,
                                self.FuncLineID,
                                self.TagType,
                                self.TagID,
                                self.State,
                                self.TurnNum,
                                self.TurnMax,
                                self.Len,
                                self.Msg
                                )
        return DumpString


m_NAtagMCTurnFightState=tagMCTurnFightState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTurnFightState.Head.Cmd,m_NAtagMCTurnFightState.Head.SubCmd))] = m_NAtagMCTurnFightState


#------------------------------------------------------
# C1 09 ¿ç·þÅÅλÍæ¼ÒÐÅÏ¢ #tagMCChampionshipPlayerInfo

class  tagMCChampionshipPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("WorshipCount", c_ubyte),    # ½ñÈÕÒÑĤ°Ý´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x09
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xC1
        self.SubCmd = 0x09
        self.WorshipCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCChampionshipPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 09 ¿ç·þÅÅλÍæ¼ÒÐÅÏ¢ //tagMCChampionshipPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                WorshipCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.WorshipCount
                                )
        return DumpString


m_NAtagMCChampionshipPlayerInfo=tagMCChampionshipPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChampionshipPlayerInfo.Cmd,m_NAtagMCChampionshipPlayerInfo.SubCmd))] = m_NAtagMCChampionshipPlayerInfo


#------------------------------------------------------
# C1 07 ¿ç·þÕ½³¡Íæ¼ÒÐÅÏ¢ #tagMCCrossBattlefieldPlayerInfo

class  tagMCCrossBattlefieldPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("BuyOpenCountToday", c_ubyte),    # ½ñÈÕÒѹºÂò¿ªÆôÕ½³¡´ÎÊý
                  ("HighScoreToday", c_int),    # ½ñÈÕ×î¸ß»ý·Ö
                  ("EnterCountWeek", c_int),    # ±¾ÖÜ×ܲÎÓë´ÎÊý
                  ("BuyOpenCountWeek", c_int),    # ±¾ÖÜ×ܹºÂòÕÙ¼¯´ÎÊý
                  ("HighScoreTotalWeek", c_int),    # ±¾ÖÜÿÈÕ×î¸ß·ÖÀÛ¼Ó×Ü·Ö
                  ("ZoneID", c_ubyte),    # ËùÊô·ÖÇøID
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x07
        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 = 0x07
        self.BuyOpenCountToday = 0
        self.HighScoreToday = 0
        self.EnterCountWeek = 0
        self.BuyOpenCountWeek = 0
        self.HighScoreTotalWeek = 0
        self.ZoneID = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossBattlefieldPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 07 ¿ç·þÕ½³¡Íæ¼ÒÐÅÏ¢ //tagMCCrossBattlefieldPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                BuyOpenCountToday:%d,
                                HighScoreToday:%d,
                                EnterCountWeek:%d,
                                BuyOpenCountWeek:%d,
                                HighScoreTotalWeek:%d,
                                ZoneID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.BuyOpenCountToday,
                                self.HighScoreToday,
                                self.EnterCountWeek,
                                self.BuyOpenCountWeek,
                                self.HighScoreTotalWeek,
                                self.ZoneID
                                )
        return DumpString


m_NAtagMCCrossBattlefieldPlayerInfo=tagMCCrossBattlefieldPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossBattlefieldPlayerInfo.Cmd,m_NAtagMCCrossBattlefieldPlayerInfo.SubCmd))] = m_NAtagMCCrossBattlefieldPlayerInfo


#------------------------------------------------------
# C1 02 ¿ç·þPKÍæ¼Ò½±Àø¼Ç¼ #tagMCCrossRealmPKAwardState

class  tagMCCrossRealmPKAwardState(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DayPKCountAwardState", c_int),    # ÿÈÕÆ¥Åä´ÎÊý½±Àø¼Ç¼£¬¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡£¬°´Æ¥Åä´ÎÊýÉýÐòÅÅÐòË÷Òý´ú±í½±Àøλ
                  ("DayWinCountAwardState", c_int),    # ÿÈÕʤÀû´ÎÊý½±Àø¼Ç¼£¬¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡£¬°´Ê¤Àû´ÎÊýÉýÐòÅÅÐòË÷Òý´ú±í½±Àøλ
                  ("DanLVAwardState", c_int),    # ¶Îλ´ï±ê½±Àø¼Ç¼£¬¶þ½øÖÆλ´æ´¢ÊÇ·ñÒÑÁìÈ¡£¬°´¶Îλ´ú±í½±Àøλ
                  ("SeasonAwardState", c_ubyte),    # Èü¼¾½áËã½±ÀøÊÇ·ñÒÑÁìÈ¡
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x02
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xC1
        self.SubCmd = 0x02
        self.DayPKCountAwardState = 0
        self.DayWinCountAwardState = 0
        self.DanLVAwardState = 0
        self.SeasonAwardState = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossRealmPKAwardState)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 02 ¿ç·þPKÍæ¼Ò½±Àø¼Ç¼ //tagMCCrossRealmPKAwardState:
                                Cmd:%s,
                                SubCmd:%s,
                                DayPKCountAwardState:%d,
                                DayWinCountAwardState:%d,
                                DanLVAwardState:%d,
                                SeasonAwardState:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DayPKCountAwardState,
                                self.DayWinCountAwardState,
                                self.DanLVAwardState,
                                self.SeasonAwardState
                                )
        return DumpString


m_NAtagMCCrossRealmPKAwardState=tagMCCrossRealmPKAwardState()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossRealmPKAwardState.Cmd,m_NAtagMCCrossRealmPKAwardState.SubCmd))] = m_NAtagMCCrossRealmPKAwardState


#------------------------------------------------------
# C1 03 ¿ç·þPKÍæ¼ÒÀúÊ·Èü¼¾ÐÅÏ¢ #tagMCCrossRealmPKPlayerHisSeasonInfo

class  tagMCCrossRealmPKPlayerHisSeason(Structure):
    _pack_ = 1
    _fields_ = [
                  ("SeasonID", c_ushort),    # Èü¼¾ID
                  ("Order", c_ushort),    # Ãû´Î
                  ("DanLV", c_ubyte),    # ¶Îλ
                  ("Score", c_int),    # »ý·Ö
                  ("AwardLV", c_ubyte),    # Èü¼¾½áËã½±ÀøµÈ¼¶£¬±ÈÈçÍõÕß·¨±¦µÄÊôÐÔÈ¡¸ÃµÈ¼¶¶ÔÓ¦ÊôÐÔ
                  ]

    def __init__(self):
        self.Clear()
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.SeasonID = 0
        self.Order = 0
        self.DanLV = 0
        self.Score = 0
        self.AwardLV = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossRealmPKPlayerHisSeason)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 03 ¿ç·þPKÍæ¼ÒÀúÊ·Èü¼¾ÐÅÏ¢ //tagMCCrossRealmPKPlayerHisSeasonInfo:
                                SeasonID:%d,
                                Order:%d,
                                DanLV:%d,
                                Score:%d,
                                AwardLV:%d
                                '''\
                                %(
                                self.SeasonID,
                                self.Order,
                                self.DanLV,
                                self.Score,
                                self.AwardLV
                                )
        return DumpString


class  tagMCCrossRealmPKPlayerHisSeasonInfo(Structure):
    Head = tagHead()
    Count = 0    #(WORD Count)// Èü¼¾¸öÊý
    SeasonList = list()    #(vector<tagMCCrossRealmPKPlayerHisSeason> SeasonList)// Èü¼¾ÐÅÏ¢Áбí
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0xC1
        self.Head.SubCmd = 0x03
        return

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.Count):
            temSeasonList = tagMCCrossRealmPKPlayerHisSeason()
            _pos = temSeasonList.ReadData(_lpData, _pos)
            self.SeasonList.append(temSeasonList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0xC1
        self.Head.SubCmd = 0x03
        self.Count = 0
        self.SeasonList = list()
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 2
        for i in range(self.Count):
            length += self.SeasonList[i].GetLength()

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteWORD(data, self.Count)
        for i in range(self.Count):
            data = CommFunc.WriteString(data, self.SeasonList[i].GetLength(), self.SeasonList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                Count:%d,
                                SeasonList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.Count,
                                "..."
                                )
        return DumpString


m_NAtagMCCrossRealmPKPlayerHisSeasonInfo=tagMCCrossRealmPKPlayerHisSeasonInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossRealmPKPlayerHisSeasonInfo.Head.Cmd,m_NAtagMCCrossRealmPKPlayerHisSeasonInfo.Head.SubCmd))] = m_NAtagMCCrossRealmPKPlayerHisSeasonInfo


#------------------------------------------------------
# C1 01 ¿ç·þPKÍæ¼ÒÐÅÏ¢ #tagMCCrossRealmPKPlayerInfo

class  tagMCCrossRealmPKPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("Score", c_int),    # µ±Ç°»ý·Ö
                  ("DanLV", c_ubyte),    # µ±Ç°¶Îλ
                  ("PKCount", c_ushort),    # PK´ÎÊý
                  ("WinCount", c_ushort),    # ʤÀû´ÎÊý
                  ("CWinCount", c_ushort),    # Á¬Ê¤´ÎÊý
                  ("DayPKCount", c_ubyte),    # µ±ÈÕÒÑPK´ÎÊý
                  ("DayWinCount", c_ubyte),    # µ±ÈÕÒÑʤÀû´ÎÊý
                  ("DayBuyCount", c_ubyte),    # µ±ÈÕÒѹºÂò´ÎÊý
                  ("DayItemAddCount", c_ubyte),    # µ±ÈÕÎïÆ·Ôö¼Ó´ÎÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x01
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xC1
        self.SubCmd = 0x01
        self.Score = 0
        self.DanLV = 0
        self.PKCount = 0
        self.WinCount = 0
        self.CWinCount = 0
        self.DayPKCount = 0
        self.DayWinCount = 0
        self.DayBuyCount = 0
        self.DayItemAddCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCCrossRealmPKPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 01 ¿ç·þPKÍæ¼ÒÐÅÏ¢ //tagMCCrossRealmPKPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                Score:%d,
                                DanLV:%d,
                                PKCount:%d,
                                WinCount:%d,
                                CWinCount:%d,
                                DayPKCount:%d,
                                DayWinCount:%d,
                                DayBuyCount:%d,
                                DayItemAddCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Score,
                                self.DanLV,
                                self.PKCount,
                                self.WinCount,
                                self.CWinCount,
                                self.DayPKCount,
                                self.DayWinCount,
                                self.DayBuyCount,
                                self.DayItemAddCount
                                )
        return DumpString


m_NAtagMCCrossRealmPKPlayerInfo=tagMCCrossRealmPKPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossRealmPKPlayerInfo.Cmd,m_NAtagMCCrossRealmPKPlayerInfo.SubCmd))] = m_NAtagMCCrossRealmPKPlayerInfo


#------------------------------------------------------
# C1 06 ½øÈë¿ç·þ·þÎñÆ÷´íÎó #tagMCEnterCrossServerError

class  tagMCEnterCrossServerError(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x06
        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 = 0x06
        return

    def GetLength(self):
        return sizeof(tagMCEnterCrossServerError)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 06 ½øÈë¿ç·þ·þÎñÆ÷´íÎó //tagMCEnterCrossServerError:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


m_NAtagMCEnterCrossServerError=tagMCEnterCrossServerError()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCEnterCrossServerError.Cmd,m_NAtagMCEnterCrossServerError.SubCmd))] = m_NAtagMCEnterCrossServerError


#------------------------------------------------------
# C1 08 ÐÒÔËÔƹºÍæ¼ÒÐÅÏ¢ #tagMCLuckyCloudBuyPlayerInfo

class  tagMCLuckyCloudBuyPlayerInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("BuyCount", c_ushort),    # ±¾ÂÖÒѹºÂò·ÝÊý
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x08
        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 = 0x08
        self.BuyCount = 0
        return

    def GetLength(self):
        return sizeof(tagMCLuckyCloudBuyPlayerInfo)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 08 ÐÒÔËÔƹºÍæ¼ÒÐÅÏ¢ //tagMCLuckyCloudBuyPlayerInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                BuyCount:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.BuyCount
                                )
        return DumpString


m_NAtagMCLuckyCloudBuyPlayerInfo=tagMCLuckyCloudBuyPlayerInfo()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCLuckyCloudBuyPlayerInfo.Cmd,m_NAtagMCLuckyCloudBuyPlayerInfo.SubCmd))] = m_NAtagMCLuckyCloudBuyPlayerInfo


#------------------------------------------------------
# C1 04 ×¼±¸½øÈë¿ç·þ·þÎñÆ÷ #tagMCPrepareEnterCrossServer

class  tagMCPrepareEnterCrossServer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("DataMapID", c_int),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x04
        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 = 0x04
        self.DataMapID = 0
        return

    def GetLength(self):
        return sizeof(tagMCPrepareEnterCrossServer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 04 ×¼±¸½øÈë¿ç·þ·þÎñÆ÷ //tagMCPrepareEnterCrossServer:
                                Cmd:%s,
                                SubCmd:%s,
                                DataMapID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.DataMapID
                                )
        return DumpString


m_NAtagMCPrepareEnterCrossServer=tagMCPrepareEnterCrossServer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPrepareEnterCrossServer.Cmd,m_NAtagMCPrepareEnterCrossServer.SubCmd))] = m_NAtagMCPrepareEnterCrossServer


#------------------------------------------------------
# C1 05 ¿ªÊ¼½øÈë¿ç·þ·þÎñÆ÷ #tagMCStartEnterCrossServer

class  tagMCStartEnterCrossServer(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0xC1
        self.SubCmd = 0x05
        return

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        memmove(addressof(self), stringData[_pos:], self.GetLength())
        return _pos + self.GetLength()

    def Clear(self):
        self.Cmd = 0xC1
        self.SubCmd = 0x05
        return

    def GetLength(self):
        return sizeof(tagMCStartEnterCrossServer)

    def GetBuffer(self):
        return string_at(addressof(self), self.GetLength())

    def OutputString(self):
        DumpString = '''// C1 05 ¿ªÊ¼½øÈë¿ç·þ·þÎñÆ÷ //tagMCStartEnterCrossServer:
                                Cmd:%s,
                                SubCmd:%s
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd
                                )
        return DumpString


m_NAtagMCStartEnterCrossServer=tagMCStartEnterCrossServer()
ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCStartEnterCrossServer.Cmd,m_NAtagMCStartEnterCrossServer.SubCmd))] = m_NAtagMCStartEnterCrossServer