#!/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
#------------------------------------------------------
#02 02 Íæ¼Ò½»Ò×ËùÌí¼Ó³öÊÛµÄÎïÆ·#tagMGAddPlayerSellBourseItem

class  tagMGAddPlayerSellBourseItem(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])//³öÊÛÍæ¼Ò½ÇÉ«Ãû£¬size = 33
    OperateInfo = 0    #(DWORD OperateInfo)//³öÊÛÍæ¼ÒÔËÓªÉ̸½¼ÓÐÅÏ¢
    ItemGUID = ""    #(char ItemGUID[40])
    Count = 0    #(WORD Count)//³öÊÛÊýÁ¿
    PriceType = 0    #(BYTE PriceType)//³öÊÛ¼Û¸ñÀàÐÍ
    PriceCount = 0    #(DWORD PriceCount)//³öÊÛ¼Û¸ñ
    ItemTypeID = 0    #(DWORD ItemTypeID)//ÎïÆ·ID
    UserDataLen = 0    #(DWORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    Type = 0    #(DWORD Type)//ÎïÆ·ÀàÐÍ--sys
    EquipPlace = 0    #(BYTE EquipPlace)//×°±¸Î»ÖÃ--sys
    LV = 0    #(WORD LV)//ÎïÆ·µÈ¼¶--sys
    UseLV = 0    #(WORD UseLV)//ʹÓõȼ¶--sys
    JobLimit = 0    #(DWORD JobLimit)//Ö°ÒµÏÞÖÆ,λ²Ù×÷--sys
    SuiteID = 0    #(DWORD SuiteID)//Ì××°ID--sys
    ItemQuality = 0    #(BYTE ItemQuality)//×°±¸Æ·ÖÊ--sys
    ItemColor = 0    #(BYTE ItemColor)//×°±¸ÑÕÉ«Æ·ÖÊ--sys
    Pwd = ""    #(char Pwd[8])//½»Ò×ÃÜÂë
    EquipGS = 0    #(DWORD EquipGS)//×°±¸ÆÀ·Ö
    ItemName = ""    #(char ItemName[33])//ÎïÆ·Ãû(Ä£ºý²éѯ)
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x02
        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.OperateInfo,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PriceType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PriceCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemTypeID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        self.Type,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipPlace,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.UseLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.JobLimit,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SuiteID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemQuality,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemColor,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Pwd,_pos = CommFunc.ReadString(_lpData, _pos,8)
        self.EquipGS,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x02
        self.PlayerID = 0
        self.PlayerName = ""
        self.OperateInfo = 0
        self.ItemGUID = ""
        self.Count = 0
        self.PriceType = 0
        self.PriceCount = 0
        self.ItemTypeID = 0
        self.UserDataLen = 0
        self.UserData = ""
        self.Type = 0
        self.EquipPlace = 0
        self.LV = 0
        self.UseLV = 0
        self.JobLimit = 0
        self.SuiteID = 0
        self.ItemQuality = 0
        self.ItemColor = 0
        self.Pwd = ""
        self.EquipGS = 0
        self.ItemName = ""
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 33
        length += 4
        length += 40
        length += 2
        length += 1
        length += 4
        length += 4
        length += 4
        length += len(self.UserData)
        length += 4
        length += 1
        length += 2
        length += 2
        length += 4
        length += 4
        length += 1
        length += 1
        length += 8
        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.PlayerName)
        data = CommFunc.WriteDWORD(data, self.OperateInfo)
        data = CommFunc.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.PriceType)
        data = CommFunc.WriteDWORD(data, self.PriceCount)
        data = CommFunc.WriteDWORD(data, self.ItemTypeID)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        data = CommFunc.WriteDWORD(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.EquipPlace)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteWORD(data, self.UseLV)
        data = CommFunc.WriteDWORD(data, self.JobLimit)
        data = CommFunc.WriteDWORD(data, self.SuiteID)
        data = CommFunc.WriteBYTE(data, self.ItemQuality)
        data = CommFunc.WriteBYTE(data, self.ItemColor)
        data = CommFunc.WriteString(data, 8, self.Pwd)
        data = CommFunc.WriteDWORD(data, self.EquipGS)
        data = CommFunc.WriteString(data, 33, self.ItemName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                OperateInfo:%d,
                                ItemGUID:%s,
                                Count:%d,
                                PriceType:%d,
                                PriceCount:%d,
                                ItemTypeID:%d,
                                UserDataLen:%d,
                                UserData:%s,
                                Type:%d,
                                EquipPlace:%d,
                                LV:%d,
                                UseLV:%d,
                                JobLimit:%d,
                                SuiteID:%d,
                                ItemQuality:%d,
                                ItemColor:%d,
                                Pwd:%s,
                                EquipGS:%d,
                                ItemName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PlayerName,
                                self.OperateInfo,
                                self.ItemGUID,
                                self.Count,
                                self.PriceType,
                                self.PriceCount,
                                self.ItemTypeID,
                                self.UserDataLen,
                                self.UserData,
                                self.Type,
                                self.EquipPlace,
                                self.LV,
                                self.UseLV,
                                self.JobLimit,
                                self.SuiteID,
                                self.ItemQuality,
                                self.ItemColor,
                                self.Pwd,
                                self.EquipGS,
                                self.ItemName
                                )
        return DumpString


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


#------------------------------------------------------
#02 04 Íæ¼ÒÈ·ÈϹºÂò½»Ò×ËùÎïÆ·#tagMGBuyBourseItemSure

class  tagMGBuyBourseItemSure(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    PlayerName = ""    #(char PlayerName[33])//¹ºÂòÍæ¼Ò½ÇÉ«Ãû£¬size = 33
    ItemGUID = ""    #(char ItemGUID[40])
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x02
        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.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x04
        self.PlayerID = 0
        self.PlayerName = ""
        self.ItemGUID = ""
        return

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

        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.WriteString(data, 40, self.ItemGUID)
        return data

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


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


#------------------------------------------------------
#02 01 ѯÎÊÊÇ·ñ¿ÉÒÔÌí¼ÓÍæ¼Ò½»Ò×ËùÎïÆ·#tagMGCheckAddPlayerBourseItem

class  tagMGCheckAddPlayerBourseItem(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    ItemIndex = 0    #(BYTE ItemIndex)//ÎïÆ·ÔÚ±³°üÖÐË÷Òý
    Count = 0    #(WORD Count)//³öÊÛÊýÁ¿
    PriceType = 0    #(BYTE PriceType)//³öÊÛ¼Û¸ñÀàÐÍ
    PriceCount = 0    #(DWORD PriceCount)//³öÊÛ¼Û¸ñ
    Pwd = ""    #(char Pwd[8])//½»Ò×ÃÜÂë
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x02
        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.ItemIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PriceType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PriceCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Pwd,_pos = CommFunc.ReadString(_lpData, _pos,8)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x01
        self.PlayerID = 0
        self.ItemIndex = 0
        self.Count = 0
        self.PriceType = 0
        self.PriceCount = 0
        self.Pwd = ""
        return

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

        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.ItemIndex)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.PriceType)
        data = CommFunc.WriteDWORD(data, self.PriceCount)
        data = CommFunc.WriteString(data, 8, self.Pwd)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                ItemIndex:%d,
                                Count:%d,
                                PriceType:%d,
                                PriceCount:%d,
                                Pwd:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.ItemIndex,
                                self.Count,
                                self.PriceType,
                                self.PriceCount,
                                self.Pwd
                                )
        return DumpString


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


#------------------------------------------------------
#02 03 Íæ¼ÒѯÎʹºÂò½»Ò×ËùÎïÆ·#tagMGCheckBuyBourseItem

class  tagMGCheckBuyBourseItem(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    ItemGUID = ""    #(char ItemGUID[40])
    Pwd = ""    #(char Pwd[8])//½»Ò×ÃÜÂë
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x03
        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.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.Pwd,_pos = CommFunc.ReadString(_lpData, _pos,8)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x03
        self.PlayerID = 0
        self.ItemGUID = ""
        self.Pwd = ""
        return

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

        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, 40, self.ItemGUID)
        data = CommFunc.WriteString(data, 8, self.Pwd)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                ItemGUID:%s,
                                Pwd:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.ItemGUID,
                                self.Pwd
                                )
        return DumpString


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


#------------------------------------------------------
#02 05 ½»Ò×ËùÍæ¼ÒÈ¡ÏÂÕýÔÚ³öÊÛµÄÎïÆ·»ò³öÊÛÊÕÒæ#tagMGPlayerRecaptureBourseItem

class  tagMGPlayerRecaptureBourseItem(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    ItemGUID = ""    #(char ItemGUID[40])
    PackSpaceCount = 0    #(BYTE PackSpaceCount)//µ±Ç°±³°üÊ£Óà¿Õ¼ä
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x02
        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.ItemGUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.PackSpaceCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x02
        self.Head.SubCmd = 0x05
        self.PlayerID = 0
        self.ItemGUID = ""
        self.PackSpaceCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 40
        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.WriteString(data, 40, self.ItemGUID)
        data = CommFunc.WriteBYTE(data, self.PackSpaceCount)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                ItemGUID:%s,
                                PackSpaceCount:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.ItemGUID,
                                self.PackSpaceCount
                                )
        return DumpString


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


#------------------------------------------------------
#04 02 µØͼ²éѯÍæ¼Ò»º´æÊý¾Ý#tagMGQueryPlayerCache

class  tagMGQueryPlayerCache(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    #Íæ¼ÒID
                  ("FindPlayerID", c_int),    #Òª²éѯµÄÍæ¼ÒID
                  ]

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

    def GetLength(self):
        return sizeof(tagMGQueryPlayerCache)

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

    def OutputString(self):
        DumpString = '''//04 02 µØͼ²éѯÍæ¼Ò»º´æÊý¾Ý//tagMGQueryPlayerCache:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                FindPlayerID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.FindPlayerID
                                )
        return DumpString


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


#------------------------------------------------------
#04 01 µØͼͬ²½Íæ¼Ò»º´æÊý¾Ýµ½GameServer#tagMGUpdatePlayerCache

class  tagMGUpdatePlayerCache(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PlayerLV = 0    #(WORD PlayerLV)//Íæ¼ÒµÈ¼¶
    PropDataSize = 0    #(DWORD PropDataSize)
    PropData = ""    #(String PropData)//ÊôÐԼǼ
    ItemDataSize = 0    #(DWORD ItemDataSize)
    ItemData = ""    #(String ItemData)//ÎïÆ·¼Ç¼
    PlusDataSize = 0    #(DWORD PlusDataSize)
    PlusData = ""    #(String PlusData)//À©Õ¹¼Ç¼
    IsLogouting = 0    #(BYTE IsLogouting)//±¾´ÎÊÇ·ñΪÏÂÏßͬ²½
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x04
        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.PlayerLV,_pos = CommFunc.ReadWORD(_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)
        self.IsLogouting,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x04
        self.Head.SubCmd = 0x01
        self.PlayerID = 0
        self.PlayerLV = 0
        self.PropDataSize = 0
        self.PropData = ""
        self.ItemDataSize = 0
        self.ItemData = ""
        self.PlusDataSize = 0
        self.PlusData = ""
        self.IsLogouting = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 2
        length += 4
        length += len(self.PropData)
        length += 4
        length += len(self.ItemData)
        length += 4
        length += len(self.PlusData)
        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.WriteWORD(data, self.PlayerLV)
        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)
        data = CommFunc.WriteBYTE(data, self.IsLogouting)
        return data

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


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


#------------------------------------------------------
# 03 05 Ôö¼Ó¼Ò×åÊôÐÔ#tagMGAddFamilyDetail

class  tagMGAddFamilyDetail(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    #Íæ¼ÒID
                  ("AddFamilyHornor", c_int),    #Ôö¼Ó¼Ò×åÈÙÓþ
                  ("AddFamilyMoney", c_int),    #Ôö¼Ó¼Ò×å×ʽð
                  ("FamilyActiveValue", c_int),    #¼Ò×å»îÔ¾¶È
                  ("AddResion", c_ubyte),    #Ôö¼ÓÔ­Òò
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0x03
        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 = 0x03
        self.SubCmd = 0x05
        self.PlayerID = 0
        self.AddFamilyHornor = 0
        self.AddFamilyMoney = 0
        self.FamilyActiveValue = 0
        self.AddResion = 0
        return

    def GetLength(self):
        return sizeof(tagMGAddFamilyDetail)

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

    def OutputString(self):
        DumpString = '''// 03 05 Ôö¼Ó¼Ò×åÊôÐÔ//tagMGAddFamilyDetail:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                AddFamilyHornor:%d,
                                AddFamilyMoney:%d,
                                FamilyActiveValue:%d,
                                AddResion:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.AddFamilyHornor,
                                self.AddFamilyMoney,
                                self.FamilyActiveValue,
                                self.AddResion
                                )
        return DumpString


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


#------------------------------------------------------
#03 02 ÌìÌݾº¼¼³¡Íæ¼Ò·¢ÆðÌôÕ½#tagMGHighLadderChallenge

class  tagHightLadderItemInfo(Structure):
    ItemTypeID = 0    #(DWORD ItemTypeID)//ÎïÆ·ID
    ItemPlaceType = 0    #(BYTE ItemPlaceType)//ÎïƷλÖõı³°üÀàÐÍ
    ItemPlaceIndex = 0    #(BYTE ItemPlaceIndex)//ÎïÆ·ËùÔÚµÄË÷Òý
    Count = 0    #(WORD Count)//µ¥×éÊýÁ¿
    ItemStarLV = 0    #(BYTE ItemStarLV)//×°±¸ÐǼ¶
    IdentifyPar = 0    #(BYTE IdentifyPar)//¼ø¶¨²ÎÊý
    CurDurg = 0    #(DWORD CurDurg)//µ±Ç°Ä;Ã
    MaxDurg = 0    #(DWORD MaxDurg)//×î´óÄ;Ã
    CanPlaceStoneCount = 0    #(BYTE CanPlaceStoneCount)//¿ÉÏâǶ±¦Ê¯Êý0±íʾ²»¿ÉÒÔÏâǶ±¦Ê¯
    ItemProperty = 0    #(BYTE ItemProperty)//×°±¸ÎåÐÐ
    SoulProperty = 0    #(WORD SoulProperty)//Áé»êÊôÐÔÊôÐÔ
    Maker = 0    #(DWORD Maker)//ÖÆ×÷ÕßID
    MakerName = ""    #(char MakerName[33])//ÖÆÔìÕßÃû×Ö
    Stone1 = 0    #(DWORD Stone1)//ÏâǶ±¦Ê¯1
    Stone2 = 0    #(DWORD Stone2)//ÏâǶ±¦Ê¯
    Stone3 = 0    #(DWORD Stone3)//ÏâǶ±¦Ê¯
    Stone4 = 0    #(DWORD Stone4)//ÏâǶ±¦Ê¯
    Stone5 = 0    #(DWORD Stone5)//ÏâǶ±¦Ê¯
    Stone6 = 0    #(DWORD Stone6)//ÏâǶ±¦Ê¯
    Stone7 = 0    #(DWORD Stone7)//ÏâǶ±¦Ê¯
    Stone8 = 0    #(DWORD Stone8)//ÏâǶ±¦Ê¯
    Stone9 = 0    #(DWORD Stone9)//ÏâǶ±¦Ê¯
    IsRenZhu = 0    #(BYTE IsRenZhu)//ÊÇ·ñÈÏÖ÷
    EquipDefenseValue = 0    #(DWORD EquipDefenseValue)//ÓÃÓڼǼװ±¸µÄ·ÀÓùÖµ
    EquipMinAtkValue = 0    #(DWORD EquipMinAtkValue)//ÓÃÓڼǼװ±¸µÄ×îСÉ˺¦Öµ
    EquipMaxAtkValue = 0    #(DWORD EquipMaxAtkValue)//ÓÃÓڼǼװ±¸µÄ×î´óÉ˺¦Öµ
    UserDataLen = 0    #(DWORD UserDataLen)
    UserData = ""    #(String UserData)//×Ô¶¨ÒåÊý¾Ý
    FitLV = 0    #(BYTE FitLV)//ÎïÆ·ÆõºÏµÈ¼¶
    Proficiency = 0    #(DWORD Proficiency)//ÊìÁ·¶È
    IsSuite = 0    #(BYTE IsSuite)//ÊÇ·ñÒѾ­Ì××°»¯
    BaseHP = 0    #(DWORD BaseHP)// HP»ù´¡Öµ
    BaseMagicDef = 0    #(DWORD BaseMagicDef)//ÄÚ·À»ù´¡Öµ
    MaxAddSkillCnt = 0    #(BYTE MaxAddSkillCnt)// ×î´ó¸½Ä§´ÎÊý
    PetID = 0    #(DWORD PetID)//×°±¸¸Ã×°±¸µÄ³èÎïID£¬Îª0Ôòδװ±¸
    EquipMagicDefValue = 0    #(DWORD EquipMagicDefValue)//×°±¸ÄÚ·ÀÖµ
    EquipMinMagicAtkValue = 0    #(DWORD EquipMinMagicAtkValue)//×°±¸×îСÄÚ¹¥
    EquipMaxMagicAtkValue = 0    #(DWORD EquipMaxMagicAtkValue)//×°±¸×î´óÄÚ¹¥
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.ItemTypeID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemPlaceType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemPlaceIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.ItemStarLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IdentifyPar,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CurDurg,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxDurg,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.CanPlaceStoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemProperty,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SoulProperty,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Maker,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MakerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Stone1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Stone9,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsRenZhu,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.EquipDefenseValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMinAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMaxAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        self.FitLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Proficiency,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.IsSuite,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.BaseHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BaseMagicDef,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxAddSkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PetID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMagicDefValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMinMagicAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMaxMagicAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.ItemTypeID = 0
        self.ItemPlaceType = 0
        self.ItemPlaceIndex = 0
        self.Count = 0
        self.ItemStarLV = 0
        self.IdentifyPar = 0
        self.CurDurg = 0
        self.MaxDurg = 0
        self.CanPlaceStoneCount = 0
        self.ItemProperty = 0
        self.SoulProperty = 0
        self.Maker = 0
        self.MakerName = ""
        self.Stone1 = 0
        self.Stone2 = 0
        self.Stone3 = 0
        self.Stone4 = 0
        self.Stone5 = 0
        self.Stone6 = 0
        self.Stone7 = 0
        self.Stone8 = 0
        self.Stone9 = 0
        self.IsRenZhu = 0
        self.EquipDefenseValue = 0
        self.EquipMinAtkValue = 0
        self.EquipMaxAtkValue = 0
        self.UserDataLen = 0
        self.UserData = ""
        self.FitLV = 0
        self.Proficiency = 0
        self.IsSuite = 0
        self.BaseHP = 0
        self.BaseMagicDef = 0
        self.MaxAddSkillCnt = 0
        self.PetID = 0
        self.EquipMagicDefValue = 0
        self.EquipMinMagicAtkValue = 0
        self.EquipMaxMagicAtkValue = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ItemTypeID)
        data = CommFunc.WriteBYTE(data, self.ItemPlaceType)
        data = CommFunc.WriteBYTE(data, self.ItemPlaceIndex)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.ItemStarLV)
        data = CommFunc.WriteBYTE(data, self.IdentifyPar)
        data = CommFunc.WriteDWORD(data, self.CurDurg)
        data = CommFunc.WriteDWORD(data, self.MaxDurg)
        data = CommFunc.WriteBYTE(data, self.CanPlaceStoneCount)
        data = CommFunc.WriteBYTE(data, self.ItemProperty)
        data = CommFunc.WriteWORD(data, self.SoulProperty)
        data = CommFunc.WriteDWORD(data, self.Maker)
        data = CommFunc.WriteString(data, 33, self.MakerName)
        data = CommFunc.WriteDWORD(data, self.Stone1)
        data = CommFunc.WriteDWORD(data, self.Stone2)
        data = CommFunc.WriteDWORD(data, self.Stone3)
        data = CommFunc.WriteDWORD(data, self.Stone4)
        data = CommFunc.WriteDWORD(data, self.Stone5)
        data = CommFunc.WriteDWORD(data, self.Stone6)
        data = CommFunc.WriteDWORD(data, self.Stone7)
        data = CommFunc.WriteDWORD(data, self.Stone8)
        data = CommFunc.WriteDWORD(data, self.Stone9)
        data = CommFunc.WriteBYTE(data, self.IsRenZhu)
        data = CommFunc.WriteDWORD(data, self.EquipDefenseValue)
        data = CommFunc.WriteDWORD(data, self.EquipMinAtkValue)
        data = CommFunc.WriteDWORD(data, self.EquipMaxAtkValue)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        data = CommFunc.WriteBYTE(data, self.FitLV)
        data = CommFunc.WriteDWORD(data, self.Proficiency)
        data = CommFunc.WriteBYTE(data, self.IsSuite)
        data = CommFunc.WriteDWORD(data, self.BaseHP)
        data = CommFunc.WriteDWORD(data, self.BaseMagicDef)
        data = CommFunc.WriteBYTE(data, self.MaxAddSkillCnt)
        data = CommFunc.WriteDWORD(data, self.PetID)
        data = CommFunc.WriteDWORD(data, self.EquipMagicDefValue)
        data = CommFunc.WriteDWORD(data, self.EquipMinMagicAtkValue)
        data = CommFunc.WriteDWORD(data, self.EquipMaxMagicAtkValue)
        return data

    def OutputString(self):
        DumpString = '''
                                ItemTypeID:%d,
                                ItemPlaceType:%d,
                                ItemPlaceIndex:%d,
                                Count:%d,
                                ItemStarLV:%d,
                                IdentifyPar:%d,
                                CurDurg:%d,
                                MaxDurg:%d,
                                CanPlaceStoneCount:%d,
                                ItemProperty:%d,
                                SoulProperty:%d,
                                Maker:%d,
                                MakerName:%s,
                                Stone1:%d,
                                Stone2:%d,
                                Stone3:%d,
                                Stone4:%d,
                                Stone5:%d,
                                Stone6:%d,
                                Stone7:%d,
                                Stone8:%d,
                                Stone9:%d,
                                IsRenZhu:%d,
                                EquipDefenseValue:%d,
                                EquipMinAtkValue:%d,
                                EquipMaxAtkValue:%d,
                                UserDataLen:%d,
                                UserData:%s,
                                FitLV:%d,
                                Proficiency:%d,
                                IsSuite:%d,
                                BaseHP:%d,
                                BaseMagicDef:%d,
                                MaxAddSkillCnt:%d,
                                PetID:%d,
                                EquipMagicDefValue:%d,
                                EquipMinMagicAtkValue:%d,
                                EquipMaxMagicAtkValue:%d
                                '''\
                                %(
                                self.ItemTypeID,
                                self.ItemPlaceType,
                                self.ItemPlaceIndex,
                                self.Count,
                                self.ItemStarLV,
                                self.IdentifyPar,
                                self.CurDurg,
                                self.MaxDurg,
                                self.CanPlaceStoneCount,
                                self.ItemProperty,
                                self.SoulProperty,
                                self.Maker,
                                self.MakerName,
                                self.Stone1,
                                self.Stone2,
                                self.Stone3,
                                self.Stone4,
                                self.Stone5,
                                self.Stone6,
                                self.Stone7,
                                self.Stone8,
                                self.Stone9,
                                self.IsRenZhu,
                                self.EquipDefenseValue,
                                self.EquipMinAtkValue,
                                self.EquipMaxAtkValue,
                                self.UserDataLen,
                                self.UserData,
                                self.FitLV,
                                self.Proficiency,
                                self.IsSuite,
                                self.BaseHP,
                                self.BaseMagicDef,
                                self.MaxAddSkillCnt,
                                self.PetID,
                                self.EquipMagicDefValue,
                                self.EquipMinMagicAtkValue,
                                self.EquipMaxMagicAtkValue
                                )
        return DumpString


class  tagMGHighLadderChallenge(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PlayerName = ""    #(char PlayerName[33])
    PlayerLV = 0    #(WORD PlayerLV)
    FightPower = 0    #(DWORD FightPower)
    FightPropertyDataLen = 0    #(DWORD FightPropertyDataLen)
    FightPropertyData = ""    #(String FightPropertyData)//Python×Ô¶¨ÒåÊý¾Ý
    EquipCount = 0    #(BYTE EquipCount)
    EquipList = list()    #(vector<tagHightLadderItemInfo> EquipList)//×°±¸ÐÅÏ¢Áбí
    VSOrder = 0    #(WORD VSOrder)//ÒªÌôÕ½µÄÅÅλ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x03
        self.Head.SubCmd = 0x02
        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.PlayerLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPropertyDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPropertyData,_pos = CommFunc.ReadString(_lpData, _pos,self.FightPropertyDataLen)
        self.EquipCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.EquipCount):
            temEquipList = tagHightLadderItemInfo()
            _pos = temEquipList.ReadData(_lpData, _pos)
            self.EquipList.append(temEquipList)
        self.VSOrder,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x03
        self.Head.SubCmd = 0x02
        self.PlayerID = 0
        self.PlayerName = ""
        self.PlayerLV = 0
        self.FightPower = 0
        self.FightPropertyDataLen = 0
        self.FightPropertyData = ""
        self.EquipCount = 0
        self.EquipList = list()
        self.VSOrder = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 33
        length += 2
        length += 4
        length += 4
        length += len(self.FightPropertyData)
        length += 1
        for i in range(self.EquipCount):
            length += self.EquipList[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.PlayerID)
        data = CommFunc.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteWORD(data, self.PlayerLV)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        data = CommFunc.WriteDWORD(data, self.FightPropertyDataLen)
        data = CommFunc.WriteString(data, self.FightPropertyDataLen, self.FightPropertyData)
        data = CommFunc.WriteBYTE(data, self.EquipCount)
        for i in range(self.EquipCount):
            data = CommFunc.WriteString(data, self.EquipList[i].GetLength(), self.EquipList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.VSOrder)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                PlayerLV:%d,
                                FightPower:%d,
                                FightPropertyDataLen:%d,
                                FightPropertyData:%s,
                                EquipCount:%d,
                                EquipList:%s,
                                VSOrder:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PlayerName,
                                self.PlayerLV,
                                self.FightPower,
                                self.FightPropertyDataLen,
                                self.FightPropertyData,
                                self.EquipCount,
                                "...",
                                self.VSOrder
                                )
        return DumpString


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


#------------------------------------------------------
#03 04 Íæ¼ÒÁìÈ¡²¹³¥ÎïÆ··¢·Å½á¹û#tagMGGiveCompensationResult

class  tagMGGiveCompensationResult(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    CompensationType = 0    #(BYTE CompensationType)//²¹³¥ÀàÐÍ 0 È«·þ 1 ¸öÈË
    GUID = ""    #(char GUID[40])
    Result = 0    #(BYTE Result)//·¢·Å²¹³¥½á¹û 1 ³É¹¦ 0 ʧ°Ü
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x03
        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.CompensationType,_pos = CommFunc.ReadBYTE(_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 = 0x03
        self.Head.SubCmd = 0x04
        self.PlayerID = 0
        self.CompensationType = 0
        self.GUID = ""
        self.Result = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 1
        length += 40
        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.CompensationType)
        data = CommFunc.WriteString(data, 40, self.GUID)
        data = CommFunc.WriteBYTE(data, self.Result)
        return data

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


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


#------------------------------------------------------
#03 03 Íæ¼ÒÇëÇóÁìÈ¡²¹³¥#tagMGRequestCompensation

class  tagMGRequestCompensation(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    GUID = ""    #(char GUID[40])
    PackSpaceCount = 0    #(BYTE PackSpaceCount)//µ±Ç°±³°üÊ£Óà¿Õ¼ä
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x03
        self.Head.SubCmd = 0x03
        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.GUID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.PackSpaceCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x03
        self.Head.SubCmd = 0x03
        self.PlayerID = 0
        self.GUID = ""
        self.PackSpaceCount = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 40
        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.WriteString(data, 40, self.GUID)
        data = CommFunc.WriteBYTE(data, self.PackSpaceCount)
        return data

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


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


#------------------------------------------------------
#03 01 ֪ͨѰ±¦»ñµÃÎïÆ· #tagMGNotifyTreasureRecord

class  tagMGNotifyTreasureRecord(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)//Íæ¼ÒID
    PlayerName = ""    #(char PlayerName[33])//Ñ°±¦Íæ¼Ò½ÇÉ«Ãû£¬size = 33
    Type = 0    #(BYTE Type)//Ñ°±¦ÀàÐÍ 1ÈËÎï×°±¸ 2ÈËÎïÊÎÆ· 3×øÆï×°±¸
    ItemID = 0    #(DWORD ItemID)//Ñ°±¦»ñµÃµÄÎïÆ·ID£¬Èç¹ûÊÇ
    ItemCount = 0    #(BYTE ItemCount)//ÎïÆ·ÊýÁ¿
    IsAppoint = 0    #(BYTE IsAppoint)//ÎïÆ·ÊÇ·ñÊǶ¨ÖÆÎïÆ·£¬0·ñ1ÊÇ
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x03
        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.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsAppoint,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x03
        self.Head.SubCmd = 0x01
        self.PlayerID = 0
        self.PlayerName = ""
        self.Type = 0
        self.ItemID = 0
        self.ItemCount = 0
        self.IsAppoint = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 4
        length += 33
        length += 1
        length += 4
        length += 1
        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.WriteString(data, 33, self.PlayerName)
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteBYTE(data, self.ItemCount)
        data = CommFunc.WriteBYTE(data, self.IsAppoint)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                PlayerName:%s,
                                Type:%d,
                                ItemID:%d,
                                ItemCount:%d,
                                IsAppoint:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.PlayerName,
                                self.Type,
                                self.ItemID,
                                self.ItemCount,
                                self.IsAppoint
                                )
        return DumpString


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