#!/usr/bin/python
# -*- coding: gbk -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#

#·¢ËÍ·â°üЭÒé
#ʹÓÃProtocolStudio.CodeMaker.ÆÕͨ.NewParseNetPackStruct.pyÉú³É
#Éú³ÉµÄ´úÂë²»ÄÜEclipseÖ±½Ó±£´æ£¬ÒªÍ¨¹ýUE»òÆäËû±à¼­Æ÷±£´æ£¬·ñÔò»áÌáʾ±àÂëÎÊÌâ

from ctypes import (Structure, c_int, c_ubyte, c_ulong, memset, addressof, sizeof, create_string_buffer,
                    memmove, string_at, resize, POINTER)
from Common import (CommFunc, mylog)
from PackCommonDef import tagHead

#Êý¾Ý¿â³õʼ»¯OK#tagDataServerInitOK

class  tagDataServerInitOK(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", 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
        return

    def GetLength(self):
        return sizeof(tagDataServerInitOK)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 1)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//Êý¾Ý¿â³õʼ»¯OK//tagDataServerInitOK:
                                Type:%d
                                '''\
                                %(
                                self.Type
                                )
        return DumpString

#·µ»ØÓïÑÔ°æ±¾#tagRetServerVersion

class  tagRetServerVersion(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),	
                  ("MapServerIndex", c_int),	
                  ("Version", 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.MapServerIndex = 0
        self.Version = 0
        return

    def GetLength(self):
        return sizeof(tagRetServerVersion)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 9)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//·µ»ØÓïÑÔ°æ±¾//tagRetServerVersion:
                                Type:%d,
                                MapServerIndex:%d,
                                Version:%d
                                '''\
                                %(
                                self.Type,
                                self.MapServerIndex,
                                self.Version
                                )
        return DumpString
        
#Type->Value¶¨Òå#tagDServerValueType

class  tagDServerValueType(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    
                  ("Value", 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.Value = 0
        return

    def GetLength(self):
        return sizeof(tagDServerValueType)

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

    def OutputString(self):
        DumpString = '''//Type->Value¶¨Òå//tagDServerValueType:
                                Type:%d,
                                Value:%d
                                '''\
                                %(
                                self.Type,
                                self.Value
                                )
        return DumpString

#Êý¾Ý¿â·þÎñÆ÷»Ø±¨µØͼ·þÎñÆ÷·â°üÍ·#tagDBToMapServerHead

class  tagDBToMapServerHead(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    
                  ("Success", c_ubyte),    
                  ("MapID", 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.Success = 0
        self.MapID = 0
        return

    def GetLength(self):
        return sizeof(tagDBToMapServerHead)

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

    def OutputString(self):
        DumpString = '''//Êý¾Ý¿â·þÎñÆ÷»Ø±¨µØͼ·þÎñÆ÷·â°üÍ·//tagDBToMapServerHead:
                                Type:%d,
                                Success:%d,
                                MapID:%d
                                '''\
                                %(
                                self.Type,
                                self.Success,
                                self.MapID
                                )
        return DumpString



                  
#Ö´ÐиüеĽá¹û#tagDBUpdateReturn

class  tagDBUpdateReturn(Structure):
    _pack_ = 1
    _fields_ = [
                  ("CallType", c_ubyte),	#=update
                  ("UpdateType", c_ubyte),	
                  ("Result", c_ubyte),	
                  ("MapID", c_int),	
                  ("PlayerID", c_int),	
                  ("ADOResult", 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.CallType = 0
        self.UpdateType = 0
        self.Result = 0
        self.MapID = 0
        self.PlayerID = 0
        self.ADOResult = 0
        return

    def GetLength(self):
        return sizeof(tagDBUpdateReturn)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 15)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//Ö´ÐиüеĽá¹û//tagDBUpdateReturn:
                                CallType:%d,
                                UpdateType:%d,
                                Result:%d,
                                MapID:%d,
                                PlayerID:%d,
                                ADOResult:%d
                                '''\
                                %(
                                self.CallType,
                                self.UpdateType,
                                self.Result,
                                self.MapID,
                                self.PlayerID,
                                self.ADOResult
                                )
        return DumpString

#Êý¾Ý¿â·þÎñÆ÷»Ø±¨GameServer·â°üÍ·#tagDBToGameServerHead

class  tagDBToGameServerHead(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),	
                  ("Success", 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.Success = 0
        return

    def GetLength(self):
        return sizeof(tagDBToGameServerHead)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 2)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//Êý¾Ý¿â·þÎñÆ÷»Ø±¨GameServer·â°üÍ·//tagDBToGameServerHead:
                                Type:%d,
                                Success:%d
                                '''\
                                %(
                                self.Type,
                                self.Success
                                )
        return DumpString

#·þÎñÆ÷¶Ë°æ±¾Áбí#tagServerGroupVersions

class  tagServerGroupVersion(Structure):
    _pack_ = 1
    _fields_ = [
                  ("MajorVersion", c_int),	
                  ("MinorVersion", c_int),	
                  ("LanguageVersion", 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.MajorVersion = 0
        self.MinorVersion = 0
        self.LanguageVersion = 0
        return

    def GetLength(self):
        return sizeof(tagServerGroupVersion)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 12)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//·þÎñÆ÷¶Ë°æ±¾Áбí//tagServerGroupVersions:
                                MajorVersion:%d,
                                MinorVersion:%d,
                                LanguageVersion:%d
                                '''\
                                %(
                                self.MajorVersion,
                                self.MinorVersion,
                                self.LanguageVersion
                                )
        return DumpString


class  tagServerGroupVersions(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),	
                  ("VersionCnt", c_int),	
                  ("VersionList", POINTER(tagServerGroupVersion)),	
                  ]

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

    def ReadData(self, stringData, _pos=0, _len=0):
        self.Clear()
        length = 1
        pos = 0
        memmove(addressof(self) + pos, stringData[_pos:], length)
        pos += length
        _pos += length
        length = 4
        memmove(addressof(self) + pos, stringData[_pos:], length)
        pos += length
        _pos += length

        VersionList = []
        for i in range(self.VersionCnt):
            value = tagServerGroupVersion()
            _pos = value.ReadData(stringData, _pos)
            VersionList.append(value)
        self.VersionList = (tagServerGroupVersion * self.VersionCnt)(*VersionList)

        return _pos

    def Clear(self):
        self.Type = 0
        self.VersionCnt = 0
        self.VersionList = None
        return

    def GetLength(self):
        return sizeof(tagServerGroupVersions) - sizeof(POINTER(tagServerGroupVersion)) + self.VersionCnt * sizeof(tagServerGroupVersion)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 5)
        addrOfBuf += 5
        for i in range(self.VersionCnt):
            length = self.VersionList[i].GetLength()
            memmove(addrOfBuf, self.VersionList[i].GetBuffer(), length)
            addrOfBuf += length
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        verList = []
        for i in xrange(self.VersionCnt):
            verList.append(self.VersionList[i].OutputString())
        versionList = ';'.join(verList)
        DumpString = '''//·þÎñÆ÷¶Ë°æ±¾Áбí//tagServerGroupVersions:
                                Type:%d,
                                VersionCnt:%d,
                                VersionList:%s
                                '''\
                                %(
                                self.Type,
                                self.VersionCnt,
                                versionList
                                )
        return DumpString


#GMÃüÁîÖ´Ðнá¹û#tagGMCommandResult

class  tagGMCommandResult(Structure):
    Type = 0    #(BYTE Type)
    ResultLen = 0    #(DWORD ResultLen)
    Result = ""    #(String Result)
    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.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResultLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Result,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultLen)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.ResultLen = 0
        self.Result = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.ResultLen)
        data = CommFunc.WriteString(data, self.ResultLen, self.Result)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                ResultLen:%d,
                                Result:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.Type,
                                self.ResultLen,
                                self.Result,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString
    
    
#-----------------------       
#01 22 ºÏ·þÍæ¼ÒÐÅÏ¢#tagServerMergeInfo

class  tagServerMergePlayer(Structure):
    PlayerID = 0    #(DWORD PlayerID)
    Name = ""    #(char Name[33])
    LeaderFamilyID = 0    #(DWORD LeaderFamilyID)//Èç¹ûÊǼÒ×峤µÄ»°, ¼Ò×åIDÌîд, ²»ÊǼÒ×峤¾Í²»Ìî
    Job = 0    #(BYTE Job)
    Sex = 0    #(BYTE Sex)
    LV = 0    #(WORD LV)
    TotalSTR = 0    #(DWORD TotalSTR)//Á¦Á¿
    TotalPNE = 0    #(DWORD TotalPNE)//ÕæÔª
    TotalPHY = 0    #(DWORD TotalPHY)//½î¹Ç
    TotalCON = 0    #(DWORD TotalCON)//ÌåÆÇ
    Gold = 0    #(DWORD Gold)
    GoldPaper = 0    #(DWORD GoldPaper)
    Silver = 0    #(DWORD Silver)
    SilverPaper = 0    #(DWORD SilverPaper)
    WarehouseGold = 0    #(DWORD WarehouseGold)
    WarehouseSilver = 0    #(DWORD WarehouseSilver)
    FightPower = 0    #(DWORD FightPower)//Õ½¶·Á¦
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.LeaderFamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Sex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.TotalSTR,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalPNE,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalPHY,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.TotalCON,_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.WarehouseGold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.WarehouseSilver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.PlayerID = 0
        self.Name = ""
        self.LeaderFamilyID = 0
        self.Job = 0
        self.Sex = 0
        self.LV = 0
        self.TotalSTR = 0
        self.TotalPNE = 0
        self.TotalPHY = 0
        self.TotalCON = 0
        self.Gold = 0
        self.GoldPaper = 0
        self.Silver = 0
        self.SilverPaper = 0
        self.WarehouseGold = 0
        self.WarehouseSilver = 0
        self.FightPower = 0
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 33
        length += 4
        length += 1
        length += 1
        length += 2
        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.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteString(data, 33, self.Name)
        data = CommFunc.WriteDWORD(data, self.LeaderFamilyID)
        data = CommFunc.WriteBYTE(data, self.Job)
        data = CommFunc.WriteBYTE(data, self.Sex)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteDWORD(data, self.TotalSTR)
        data = CommFunc.WriteDWORD(data, self.TotalPNE)
        data = CommFunc.WriteDWORD(data, self.TotalPHY)
        data = CommFunc.WriteDWORD(data, self.TotalCON)
        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.WarehouseGold)
        data = CommFunc.WriteDWORD(data, self.WarehouseSilver)
        data = CommFunc.WriteDWORD(data, self.FightPower)
        return data

    def OutputString(self):
        DumpString = '''
                                PlayerID:%d,
                                Name:%s,
                                LeaderFamilyID:%d,
                                Job:%d,
                                Sex:%d,
                                LV:%d,
                                TotalSTR:%d,
                                TotalPNE:%d,
                                TotalPHY:%d,
                                TotalCON:%d,
                                Gold:%d,
                                GoldPaper:%d,
                                Silver:%d,
                                SilverPaper:%d,
                                WarehouseGold:%d,
                                WarehouseSilver:%d,
                                FightPower:%d
                                '''\
                                %(
                                self.PlayerID,
                                self.Name,
                                self.LeaderFamilyID,
                                self.Job,
                                self.Sex,
                                self.LV,
                                self.TotalSTR,
                                self.TotalPNE,
                                self.TotalPHY,
                                self.TotalCON,
                                self.Gold,
                                self.GoldPaper,
                                self.Silver,
                                self.SilverPaper,
                                self.WarehouseGold,
                                self.WarehouseSilver,
                                self.FightPower
                                )
        return DumpString


class  tagServerMergeInfo(Structure):
    Head = tagHead()
    PlayerCount = 0    #(WORD PlayerCount)
    Players = list()    #(vector<tagServerMergePlayer> Players)//size = PlayerCount
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.PlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.PlayerCount):
            temPlayers = tagServerMergePlayer()
            _pos = temPlayers.ReadData(_lpData, _pos)
            self.Players.append(temPlayers)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x01
        self.Head.SubCmd = 0x22
        self.PlayerCount = 0
        self.Players = list()
        return

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

        return length

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

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

#¼ì²éÍæ¼ÒÃû³ÆÊÇ·ñ´æÔÚtagDBPlayerNameIsExist 

class  tagDBPlayerNameIsExist(Structure):
    CallType = 0    #(BYTE CallType)
    Result = 0    #(BYTE Result)
    NameLen = 0    #(BYTE NameLen)
    Name = ""    #(String Name)//size = NameLen
    PlayerID = 0    #(DWORD PlayerID)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.CallType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Result,_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)
        return _pos

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

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

        return length

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

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


class  tagPlayerMailInfo(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("InfoType", c_ubyte),    #TPlayerMailInfo
                  ]

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

    def GetLength(self):
        return sizeof(tagPlayerMailInfo)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 3)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//12 07tagPlayerMailInfo:
                                Cmd:%s,
                                SubCmd:%s,
                                InfoType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.InfoType
                                )
        return DumpString


#ÓʼþÏêÇéÍæ¼Ò²é¿´tagDBMailDetailView

class  tagDBMailDetailView(Structure):
    Type = 0    #(BYTE Type)
    MailDetailDataLen = 0    #(DWORD MailDetailDataLen)
    MailDetailData = ""    #(String MailDetailData)//size = MailDetailDataLen
    MailItemDataLen = 0    #(DWORD MailItemDataLen)
    MailItemData = ""    #(String MailItemData)//size = MailItemDataLen
    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.MailDetailDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MailDetailData,_pos = CommFunc.ReadString(_lpData, _pos,self.MailDetailDataLen)
        self.MailItemDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MailItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.MailItemDataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.MailDetailDataLen = 0
        self.MailDetailData = ""
        self.MailItemDataLen = 0
        self.MailItemData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.MailDetailDataLen)
        data = CommFunc.WriteString(data, self.MailDetailDataLen, self.MailDetailData)
        data = CommFunc.WriteDWORD(data, self.MailItemDataLen)
        data = CommFunc.WriteString(data, self.MailItemDataLen, self.MailItemData)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                MailDetailDataLen:%d,
                                MailDetailData:%s,
                                MailItemDataLen:%d,
                                MailItemData:%s
                                '''\
                                %(
                                self.Type,
                                self.MailDetailDataLen,
                                self.MailDetailData,
                                self.MailItemDataLen,
                                self.MailItemData
                                )
        return DumpString

#ÓʼþÁбíÍæ¼Ò²é¿´#tagDBGetPlayerMail

class  tagDBMailInfo(Structure):
    MailID = ""    #(char MailID[40])//ÐżþµÄID
    MailType = 0    #(BYTE MailType)//0. δ¶Á  1.Òѱ£´æ......
    LetterType = 0    #(BYTE LetterType)//¶Ô·½¸¶·Ñ, ×Ô¼º¸¶·Ñ
    SenderName = ""    #(char SenderName[33])//¼ÄÐÅÈËÃû×Ö
    Title = ""    #(char Title[21])//Ö÷Ìâ
    TitleUseSystemMessage = 0    #(BYTE TitleUseSystemMessage)//±êÌâÊÇ·ñʹÓÃSystemMessage
    ExistTime = 0    #(BYTE ExistTime)//Ðżþ´æÔÚʱ¼ä(Ìì)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        self.MailID,_pos = CommFunc.ReadString(_lpData, _pos,40)
        self.MailType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.LetterType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SenderName,_pos = CommFunc.ReadString(_lpData, _pos,33)
        self.Title,_pos = CommFunc.ReadString(_lpData, _pos,21)
        self.TitleUseSystemMessage,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExistTime,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.MailID = ""
        self.MailType = 0
        self.LetterType = 0
        self.SenderName = ""
        self.Title = ""
        self.TitleUseSystemMessage = 0
        self.ExistTime = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, 40, self.MailID)
        data = CommFunc.WriteBYTE(data, self.MailType)
        data = CommFunc.WriteBYTE(data, self.LetterType)
        data = CommFunc.WriteString(data, 33, self.SenderName)
        data = CommFunc.WriteString(data, 21, self.Title)
        data = CommFunc.WriteBYTE(data, self.TitleUseSystemMessage)
        data = CommFunc.WriteBYTE(data, self.ExistTime)
        return data

    def OutputString(self):
        DumpString = '''
                                MailID:%s,
                                MailType:%d,
                                LetterType:%d,
                                SenderName:%s,
                                Title:%s,
                                TitleUseSystemMessage:%d,
                                ExistTime:%d
                                '''\
                                %(
                                self.MailID,
                                self.MailType,
                                self.LetterType,
                                self.SenderName,
                                self.Title,
                                self.TitleUseSystemMessage,
                                self.ExistTime
                                )
        return DumpString


class  tagDBGetPlayerMail(Structure):
    Type = 0    #(BYTE Type)
    MailCount = 0    #(WORD MailCount)
    Mail = list()    #(vector<tagDBMailInfo> Mail)//size = MailCount
    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.MailCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.MailCount):
            temMail = tagDBMailInfo()
            _pos = temMail.ReadData(_lpData, _pos)
            self.Mail.append(temMail)
        return _pos

    def Clear(self):
        self.Type = 0
        self.MailCount = 0
        self.Mail = list()
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 2
        for i in range(self.MailCount):
            length += self.Mail[i].GetLength()

        return length

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

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                MailCount:%d,
                                Mail:%s
                                '''\
                                %(
                                self.Type,
                                self.MailCount,
                                "..."
                                )
        return DumpString

#Íæ¼ÒµÃµ½ÎïÆ·#tagDPlayerGetItem
class  tagDPlayerGetItem(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Type", c_ubyte),    
                  ("ItemID", c_int),    
                  ("Count", c_int),    
                  ("RemainItemCount", 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.Type = 0
        self.ItemID = 0
        self.Count = 0
        self.RemainItemCount = 0
        self.IsBind = 0
        return

    def GetLength(self):
        return sizeof(tagDPlayerGetItem)

    def GetBuffer(self):
        selfLength = self.GetLength()
        buf = create_string_buffer(selfLength)
        addrOfBuf = addressof(buf)
        memmove(addrOfBuf, addressof(self), 14)
        return string_at(addressof(buf), selfLength)

    def OutputString(self):
        DumpString = '''//Íæ¼ÒµÃµ½ÎïÆ·//tagDPlayerGetItem:
                                Type:%d,
                                ItemID:%d,
                                Count:%d,
                                RemainItemCount:%d,
                                IsBind:%d
                                '''\
                                %(
                                self.Type,
                                self.ItemID,
                                self.Count,
                                self.RemainItemCount,
                                self.IsBind
                                )
        return DumpString


#01 09 Ìí¼ÓÎïÆ·³É¹¦#tagIAddItemResult

class  tagIAddItemResult(Structure):
    Head = tagHead()
    AccLen = 0    #(BYTE AccLen)
    Acc = ""    #(String Acc)//size = AccLen
    ItemID = 0    #(DWORD ItemID)
    Count = 0    #(WORD Count)
    Result = 0    #(BYTE Result)
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.AccLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Acc,_pos = CommFunc.ReadString(_lpData, _pos,self.AccLen)
        self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x01
        self.Head.SubCmd = 0x09
        self.AccLen = 0
        self.Acc = ""
        self.ItemID = 0
        self.Count = 0
        self.Result = 0
        return

    def GetLength(self):
        length = 0
        length += self.Head.GetLength()
        length += 1
        length += len(self.Acc)
        length += 4
        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.AccLen)
        data = CommFunc.WriteString(data, self.AccLen, self.Acc)
        data = CommFunc.WriteDWORD(data, self.ItemID)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.Result)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                AccLen:%d,
                                Acc:%s,
                                ItemID:%d,
                                Count:%d,
                                Result:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.AccLen,
                                self.Acc,
                                self.ItemID,
                                self.Count,
                                self.Result
                                )
        return DumpString
    
#½ðÇ®²¹³¥±í#tagExpiation

class  tagExpiation(Structure):
    ExpiationIndex = 0    #(DWORD ExpiationIndex)//_IDT_KEY_
    AccID = ""    #(char AccID[65])//_I_
    ExpiationTime = 0    #(double ExpiationTime)//²¹³¥Ê±¼ä, ×ö¼Ç¼ÓÃ
    Gold = 0    #(DWORD Gold)//½ð×Ó
    GoldPaper = 0    #(DWORD GoldPaper)//½ðƱ
    Silver = 0    #(DWORD Silver)//Òø×Ó
    SilverPaper = 0    #(DWORD SilverPaper)//񿮱
    ItemTypeID = 0    #(DWORD ItemTypeID)//ÎïÆ·ID
    Count = 0    #(WORD Count)//µ¥×éÊýÁ¿
    IsLocked = 0    #(BYTE IsLocked)//ÊÇ·ñËø¶¨
    ItemPlaceType = 0    #(BYTE ItemPlaceType)//ÎïƷλÖõÄÀàÐÍ
    ItemPlaceIndex = 0    #(WORD ItemPlaceIndex)//ÎïÆ·ËùÔÚµÄË÷Òý
    IsBind = 0    #(BYTE IsBind)//ÊÇ·ñ°ó¶¨
    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)//ÏâǶ±¦Ê¯
    RemainHour = 0    #(WORD RemainHour)//Ê£Óàʱ¼ä(Сʱ)
    CreateTime = ""    #(char CreateTime[30])//´´½¨Ê±¼ä
    ElementEffect = 0    #(BYTE ElementEffect)//¿ª¹â״̬
    IsSuite = 0    #(BYTE IsSuite)//ÊÇ·ñÒѾ­Ì××°»¯
    FitLV = 0    #(BYTE FitLV)//ÎïÆ·ÆõºÏµÈ¼¶
    EquipAddSkillCnt = 0    #(BYTE EquipAddSkillCnt)//ÁéÎÆ´ÎÊý
    ExpireTime = 0    #(WORD ExpireTime)//ÎïÆ·ÓÐЧʱ¼ä(Сʱ)
    BaseAtkPlus = 0    #(DWORD BaseAtkPlus)//»ù´¡¹¥»÷¼Ó³É
    BaseDefPlus = 0    #(DWORD BaseDefPlus)//»ù´¡·ÀÓù¼Ó³É
    AddSkillData = ""    #(char AddSkillData[300])///ÁéÎƼ¼ÄÜÁбí×Ö·û´®
    BaseHP = 0    #(DWORD BaseHP)// HP»ù´¡Öµ
    BaseMagicDef = 0    #(DWORD BaseMagicDef)//ÄÚ·À»ù´¡Öµ
    EquipMinAtkValue = 0    #(DWORD EquipMinAtkValue)//×°±¸µÄ×îСÉ˺¦Öµ
    Proficiency = 0    #(DWORD Proficiency)//ÊìÁ·¶È
    RelMaxAddSkillCnt = 0    #(BYTE RelMaxAddSkillCnt)// ×î´ó¸½Ä§´ÎÊý
    FamilyActiveValue = 0    #(DWORD FamilyActiveValue)//¼Ò×å»îÔ¾¶È
    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.ExpiationIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
        self.ExpiationTime,_pos = CommFunc.ReadDouble(_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.ItemTypeID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsLocked,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemPlaceType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ItemPlaceIndex,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.IsBind,_pos = CommFunc.ReadBYTE(_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.RemainHour,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.CreateTime,_pos = CommFunc.ReadString(_lpData, _pos,30)
        self.ElementEffect,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.IsSuite,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FitLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.EquipAddSkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ExpireTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.BaseAtkPlus,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BaseDefPlus,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AddSkillData,_pos = CommFunc.ReadString(_lpData, _pos,300)
        self.BaseHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.BaseMagicDef,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.EquipMinAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Proficiency,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.RelMaxAddSkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.FamilyActiveValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.ExpiationIndex = 0
        self.AccID = ""
        self.ExpiationTime = 0
        self.Gold = 0
        self.GoldPaper = 0
        self.Silver = 0
        self.SilverPaper = 0
        self.ItemTypeID = 0
        self.Count = 0
        self.IsLocked = 0
        self.ItemPlaceType = 0
        self.ItemPlaceIndex = 0
        self.IsBind = 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.RemainHour = 0
        self.CreateTime = ""
        self.ElementEffect = 0
        self.IsSuite = 0
        self.FitLV = 0
        self.EquipAddSkillCnt = 0
        self.ExpireTime = 0
        self.BaseAtkPlus = 0
        self.BaseDefPlus = 0
        self.AddSkillData = ""
        self.BaseHP = 0
        self.BaseMagicDef = 0
        self.EquipMinAtkValue = 0
        self.Proficiency = 0
        self.RelMaxAddSkillCnt = 0
        self.FamilyActiveValue = 0
        self.UserDataLen = 0
        self.UserData = ""
        return

    def GetLength(self):
        length = 0
        length += 4
        length += 65
        length += 8
        length += 4
        length += 4
        length += 4
        length += 4
        length += 4
        length += 2
        length += 1
        length += 1
        length += 2
        length += 1
        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 += 2
        length += 30
        length += 1
        length += 1
        length += 1
        length += 1
        length += 2
        length += 4
        length += 4
        length += 300
        length += 4
        length += 4
        length += 4
        length += 4
        length += 1
        length += 4
        length += 4
        length += len(self.UserData)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteDWORD(data, self.ExpiationIndex)
        data = CommFunc.WriteString(data, 65, self.AccID)
        data = CommFunc.WriteDouble(data, self.ExpiationTime)
        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.ItemTypeID)
        data = CommFunc.WriteWORD(data, self.Count)
        data = CommFunc.WriteBYTE(data, self.IsLocked)
        data = CommFunc.WriteBYTE(data, self.ItemPlaceType)
        data = CommFunc.WriteWORD(data, self.ItemPlaceIndex)
        data = CommFunc.WriteBYTE(data, self.IsBind)
        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.WriteWORD(data, self.RemainHour)
        data = CommFunc.WriteString(data, 30, self.CreateTime)
        data = CommFunc.WriteBYTE(data, self.ElementEffect)
        data = CommFunc.WriteBYTE(data, self.IsSuite)
        data = CommFunc.WriteBYTE(data, self.FitLV)
        data = CommFunc.WriteBYTE(data, self.EquipAddSkillCnt)
        data = CommFunc.WriteWORD(data, self.ExpireTime)
        data = CommFunc.WriteDWORD(data, self.BaseAtkPlus)
        data = CommFunc.WriteDWORD(data, self.BaseDefPlus)
        data = CommFunc.WriteString(data, 300, self.AddSkillData)
        data = CommFunc.WriteDWORD(data, self.BaseHP)
        data = CommFunc.WriteDWORD(data, self.BaseMagicDef)
        data = CommFunc.WriteDWORD(data, self.EquipMinAtkValue)
        data = CommFunc.WriteDWORD(data, self.Proficiency)
        data = CommFunc.WriteBYTE(data, self.RelMaxAddSkillCnt)
        data = CommFunc.WriteDWORD(data, self.FamilyActiveValue)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                ExpiationIndex:%d,
                                AccID:%s,
                                ExpiationTime:%s,
                                Gold:%d,
                                GoldPaper:%d,
                                Silver:%d,
                                SilverPaper:%d,
                                ItemTypeID:%d,
                                Count:%d,
                                IsLocked:%d,
                                ItemPlaceType:%d,
                                ItemPlaceIndex:%d,
                                IsBind:%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,
                                RemainHour:%d,
                                CreateTime:%s,
                                ElementEffect:%d,
                                IsSuite:%d,
                                FitLV:%d,
                                EquipAddSkillCnt:%d,
                                ExpireTime:%d,
                                BaseAtkPlus:%d,
                                BaseDefPlus:%d,
                                AddSkillData:%s,
                                BaseHP:%d,
                                BaseMagicDef:%d,
                                EquipMinAtkValue:%d,
                                Proficiency:%d,
                                RelMaxAddSkillCnt:%d,
                                FamilyActiveValue:%d,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.ExpiationIndex,
                                self.AccID,
                                self.ExpiationTime,
                                self.Gold,
                                self.GoldPaper,
                                self.Silver,
                                self.SilverPaper,
                                self.ItemTypeID,
                                self.Count,
                                self.IsLocked,
                                self.ItemPlaceType,
                                self.ItemPlaceIndex,
                                self.IsBind,
                                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.RemainHour,
                                self.CreateTime,
                                self.ElementEffect,
                                self.IsSuite,
                                self.FitLV,
                                self.EquipAddSkillCnt,
                                self.ExpireTime,
                                self.BaseAtkPlus,
                                self.BaseDefPlus,
                                self.AddSkillData,
                                self.BaseHP,
                                self.BaseMagicDef,
                                self.EquipMinAtkValue,
                                self.Proficiency,
                                self.RelMaxAddSkillCnt,
                                self.FamilyActiveValue,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString

class  tagDMGetExpiationExResult(Structure):
    Type = 0    #(BYTE Type)
    Count = 0    #(BYTE Count)
    Datas = list()    #(vector<tagExpiation> Datas)
    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.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        for i in range(self.Count):
            temDatas = tagExpiation()
            _pos = temDatas.ReadData(_lpData, _pos)
            self.Datas.append(temDatas)
        return _pos

    def Clear(self):
        self.Type = 0
        self.Count = 0
        self.Datas = list()
        return

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

        return length

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

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                Count:%d,
                                Datas:%s
                                '''\
                                %(
                                self.Type,
                                self.Count,
                                "..."
                                )
        return DumpString
    
    
#ÇëÇó´¦Àí½á¹û#tagDRequestResult

class  tagDRequestResult(Structure):
    Type = 0    #(BYTE Type)//ÇëÇóÀàÐÍ
    Result = 0    #(BYTE Result)//´¦Àí½á¹û£¬ 0 ʧ°Ü£¬ 1 ³É¹¦
    AccID = ""    #(char AccID[65])//ÕʺÅÃû, ¸Ã½ÇÉ«ËùÔÚµÄÕʺŵÄÓû§Ãû
    ExAttr = 0    #(BYTE ExAttr)// À©Õ¹×ֶΣ¬´¦Àíʧ°Üʱ±íʾʧ°ÜµÄÔ­Òò£¬Èç¹û³É¹¦£¬×ֶκ¯ÊýÒª¸ù¾Ý¾ßÌåµÄTypeÀ´¶¨
    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.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
        self.ExAttr,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Type = 0
        self.Result = 0
        self.AccID = ""
        self.ExAttr = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 65
        length += 1

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.Result)
        data = CommFunc.WriteString(data, 65, self.AccID)
        data = CommFunc.WriteBYTE(data, self.ExAttr)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                Result:%d,
                                AccID:%s,
                                ExAttr:%d
                                '''\
                                %(
                                self.Type,
                                self.Result,
                                self.AccID,
                                self.ExAttr
                                )
        return DumpString

#ÍÆËÍmap³äÖµ¶©µ¥ #tagDMRechargePush

class  tagDMRechargePush(Structure):
    Type = 0    #(BYTE Type)
    SubType = 0    #(BYTE SubType)
    OrderIDLen = 0    #(BYTE OrderIDLen)
    OrderID = ""    #(String OrderID)// ¶©µ¥ºÅ
    OrderInfoLen = 0    #(BYTE OrderInfoLen)
    OrderInfo = ""    #(String OrderInfo)// ¶©µ¥ÐÅÏ¢£¨ÉÌÆ·±àÂ룩
    Money = 0    #(DWORD Money)//½ð¶î:·Ö
    ExtrasLen = 0    #(BYTE ExtrasLen)
    Extras = ""    #(String Extras)// À©Õ¹ÐÅÏ¢
    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.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderID,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderIDLen)
        self.OrderInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderInfoLen)
        self.Money,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ExtrasLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,self.ExtrasLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.SubType = 0
        self.OrderIDLen = 0
        self.OrderID = ""
        self.OrderInfoLen = 0
        self.OrderInfo = ""
        self.Money = 0
        self.ExtrasLen = 0
        self.Extras = ""
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 1
        length += 1
        length += len(self.OrderID)
        length += 1
        length += len(self.OrderInfo)
        length += 4
        length += 1
        length += len(self.Extras)

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.SubType)
        data = CommFunc.WriteBYTE(data, self.OrderIDLen)
        data = CommFunc.WriteString(data, self.OrderIDLen, self.OrderID)
        data = CommFunc.WriteBYTE(data, self.OrderInfoLen)
        data = CommFunc.WriteString(data, self.OrderInfoLen, self.OrderInfo)
        data = CommFunc.WriteDWORD(data, self.Money)
        data = CommFunc.WriteBYTE(data, self.ExtrasLen)
        data = CommFunc.WriteString(data, self.ExtrasLen, self.Extras)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                SubType:%d,
                                OrderIDLen:%d,
                                OrderID:%s,
                                OrderInfoLen:%d,
                                OrderInfo:%s,
                                Money:%d,
                                ExtrasLen:%d,
                                Extras:%s
                                '''\
                                %(
                                self.Type,
                                self.SubType,
                                self.OrderIDLen,
                                self.OrderID,
                                self.OrderInfoLen,
                                self.OrderInfo,
                                self.Money,
                                self.ExtrasLen,
                                self.Extras
                                )
        return DumpString

#»Ø¸´Ã½ÌåÐÂÊÖ¿¨ÊÇ·ñʹÓùý#tagDMIsMediaCardUsed

class  tagDMIsMediaCardUsed(Structure):
    Type = 0    #(BYTE Type)
    SubType = 0    #(BYTE SubType)
    CardIDLen = 0    #(BYTE CardIDLen)
    CardID = ""    #(String CardID)// size = CardIDLen
    IsUsed = 0    #(BYTE IsUsed)//ÊÇ·ñʹÓùý
    UserDataLen = 0    #(DWORD UserDataLen)
    UserData = ""    #(String UserData)//size = UserDataLen
    CardType = 0    #(BYTE CardType)
    ValidTime = ""    #(char ValidTime[20])//ÓÐЧÆÚ
    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.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CardIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CardID,_pos = CommFunc.ReadString(_lpData, _pos,self.CardIDLen)
        self.IsUsed,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        self.CardType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ValidTime,_pos = CommFunc.ReadString(_lpData, _pos,20)
        return _pos

    def Clear(self):
        self.Type = 0
        self.SubType = 0
        self.CardIDLen = 0
        self.CardID = ""
        self.IsUsed = 0
        self.UserDataLen = 0
        self.UserData = ""
        self.CardType = 0
        self.ValidTime = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.SubType)
        data = CommFunc.WriteBYTE(data, self.CardIDLen)
        data = CommFunc.WriteString(data, self.CardIDLen, self.CardID)
        data = CommFunc.WriteBYTE(data, self.IsUsed)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        data = CommFunc.WriteBYTE(data, self.CardType)
        data = CommFunc.WriteString(data, 20, self.ValidTime)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                SubType:%d,
                                CardIDLen:%d,
                                CardID:%s,
                                IsUsed:%d,
                                UserDataLen:%d,
                                UserData:%s,
                                CardType:%d,
                                ValidTime:%s
                                '''\
                                %(
                                self.Type,
                                self.SubType,
                                self.CardIDLen,
                                self.CardID,
                                self.IsUsed,
                                self.UserDataLen,
                                self.UserData,
                                self.CardType,
                                self.ValidTime
                                )
        return DumpString

#»Ø¸´¸üÐÂÐÂÊÖ¿¨×´Ì¬½á¹û#tagDMCheckUpdateMediaCardResult

class  tagDMCheckUpdateMediaCardResult(Structure):
    Type = 0    #(BYTE Type)
    SubType = 0    #(BYTE SubType)
    CardIDLen = 0    #(BYTE CardIDLen)
    CardID = ""    #(String CardID)// size = CardIDLen
    Result = 0    #(BYTE Result)//½á¹û¡£1³É¹¦£»0ʧ°Ü
    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.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CardIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.CardID,_pos = CommFunc.ReadString(_lpData, _pos,self.CardIDLen)
        self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Type = 0
        self.SubType = 0
        self.CardIDLen = 0
        self.CardID = ""
        self.Result = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.SubType)
        data = CommFunc.WriteBYTE(data, self.CardIDLen)
        data = CommFunc.WriteString(data, self.CardIDLen, self.CardID)
        data = CommFunc.WriteBYTE(data, self.Result)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                SubType:%d,
                                CardIDLen:%d,
                                CardID:%s,
                                Result:%d
                                '''\
                                %(
                                self.Type,
                                self.SubType,
                                self.CardIDLen,
                                self.CardID,
                                self.Result
                                )
        return DumpString



#GMÃüÁîÖ´Ðнá¹û#tagGMCommandResult

class  tagGMCommandResult(Structure):
    Type = 0    #(BYTE Type)
    OrderLen = 0    #(BYTE OrderLen)
    OrderId = ""    #(String OrderId)
    ResultLen = 0    #(DWORD ResultLen)
    Result = ""    #(String Result)
    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.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OrderId,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderLen)
        self.ResultLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Result,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultLen)
        self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.OrderLen = 0
        self.OrderId = ""
        self.ResultLen = 0
        self.Result = ""
        self.UserDataLen = 0
        self.UserData = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.OrderLen)
        data = CommFunc.WriteString(data, self.OrderLen, self.OrderId)
        data = CommFunc.WriteDWORD(data, self.ResultLen)
        data = CommFunc.WriteString(data, self.ResultLen, self.Result)
        data = CommFunc.WriteDWORD(data, self.UserDataLen)
        data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                OrderLen:%d,
                                OrderId:%s,
                                ResultLen:%d,
                                Result:%s,
                                UserDataLen:%d,
                                UserData:%s
                                '''\
                                %(
                                self.Type,
                                self.OrderLen,
                                self.OrderId,
                                self.ResultLen,
                                self.Result,
                                self.UserDataLen,
                                self.UserData
                                )
        return DumpString

#GameServerͨÓÃÊý¾Ý¿â²Ù×÷½á¹û#tagDGGeneralDBOperResult

class  tagDGGeneralDBOperResult(Structure):
    Type = 0    #(BYTE Type)
    Result = 0    #(BYTE Result)//½á¹û£º1³É¹¦£»0ʧ°Ü
    ResultSetLen = 0    #(DWORD ResultSetLen)
    ResultSet = ""    #(String ResultSet)//½á¹û¼¯
    ErrMsgLen = 0    #(DWORD ErrMsgLen)
    ErrMsg = ""    #(String ErrMsg)//´íÎóÐÅÏ¢
    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.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ResultSetLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ResultSet,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultSetLen)
        self.ErrMsgLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ErrMsg,_pos = CommFunc.ReadString(_lpData, _pos,self.ErrMsgLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.Result = 0
        self.ResultSetLen = 0
        self.ResultSet = ""
        self.ErrMsgLen = 0
        self.ErrMsg = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.Result)
        data = CommFunc.WriteDWORD(data, self.ResultSetLen)
        data = CommFunc.WriteString(data, self.ResultSetLen, self.ResultSet)
        data = CommFunc.WriteDWORD(data, self.ErrMsgLen)
        data = CommFunc.WriteString(data, self.ErrMsgLen, self.ErrMsg)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                Result:%d,
                                ResultSetLen:%d,
                                ResultSet:%s,
                                ErrMsgLen:%d,
                                ErrMsg:%s
                                '''\
                                %(
                                self.Type,
                                self.Result,
                                self.ResultSetLen,
                                self.ResultSet,
                                self.ErrMsgLen,
                                self.ErrMsg
                                )
        return DumpString

#------------------------------------------------------
#GameServerÏòDBÇëÇóµÄ»Ø¸´ÐÅÏ¢tagDGGameServerToDBLogicResult

class  tagDGGameServerToDBLogicResult(Structure):
    Type = 0    #(BYTE Type)
    Result = 0    #(BYTE Result)//½á¹û£º1³É¹¦£»0ʧ°Ü
    ID = 0    #(DWORD ID)//²éѯµÄID
    QueryType = 0    #(BYTE QueryType)//²éѯµÄÀàÐÍ
    DataLen = 0    #(DWORD DataLen)
    Data = ""    #(String Data)//Ô­Ñù·µ»ØµÄ¸½¼ÓÊý¾Ý
    ResultSetLen = 0    #(DWORD ResultSetLen)
    ResultSet = ""    #(String ResultSet)//½á¹û¼¯
    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.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.QueryType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.DataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
        self.ResultSetLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ResultSet,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultSetLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.Result = 0
        self.ID = 0
        self.QueryType = 0
        self.DataLen = 0
        self.Data = ""
        self.ResultSetLen = 0
        self.ResultSet = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.Result)
        data = CommFunc.WriteDWORD(data, self.ID)
        data = CommFunc.WriteBYTE(data, self.QueryType)
        data = CommFunc.WriteDWORD(data, self.DataLen)
        data = CommFunc.WriteString(data, self.DataLen, self.Data)
        data = CommFunc.WriteDWORD(data, self.ResultSetLen)
        data = CommFunc.WriteString(data, self.ResultSetLen, self.ResultSet)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                Result:%d,
                                ID:%d,
                                QueryType:%d,
                                DataLen:%d,
                                Data:%s,
                                ResultSetLen:%d,
                                ResultSet:%s
                                '''\
                                %(
                                self.Type,
                                self.Result,
                                self.ID,
                                self.QueryType,
                                self.DataLen,
                                self.Data,
                                self.ResultSetLen,
                                self.ResultSet
                                )
        return DumpString

#֪ͨGameServer¿ÉÓõļÒ×åIDÁбí#tagDGCanUseFamilyIDList

class  tagDGCanUseFamilyIDList(Structure):
    Type = 0    #(BYTE Type)
    UpdateType = 0    #(BYTE UpdateType)//0Ϊ³õʼ»¯ÇëÇó£¬1ΪÊýÁ¿²»×ãʱ²¹³äÇëÇó
    Count = 0    #(DWORD Count)
    FamilyIDList = list()    #(vector<DWORD> FamilyIDList)
    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.UpdateType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.Count,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        for i in range(self.Count):
            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
            self.FamilyIDList.append(value)
        return _pos

    def Clear(self):
        self.Type = 0
        self.UpdateType = 0
        self.Count = 0
        self.FamilyIDList = list()
        return

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

        return length

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

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

#¿ç·þ×Ó·þ¾­´úÀíµ½Ö÷·þDBת·¢µ½Ö÷·þGameServer#tagDGMergerChildToGameStringData

class  tagDGMergerChildToGameStringData(Structure):
    Type = 0    #(BYTE Type)
    DataLen = 0    #(DWORD DataLen)
    Data = ""    #(String Data)//×Ô¶¨ÒåÏûÏ¢
    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.DataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.DataLen = 0
        self.Data = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.DataLen)
        data = CommFunc.WriteString(data, self.DataLen, self.Data)
        return data

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



#------------------------------------------------------
#×Ó·þ»ã±¨Íæ¼ÒÊý¾Ý #tagDMMergePlayerData

class  tagDMMergePlayerData(Structure):
    Type = 0    #(BYTE Type)
    SubType = 0    #(BYTE SubType)
    PlayerID = 0    #(DWORD PlayerID)
    DataLen = 0    #(DWORD DataLen)
    Data = ""    #(String Data)
    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.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.DataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
        return _pos

    def Clear(self):
        self.Type = 0
        self.SubType = 0
        self.PlayerID = 0
        self.DataLen = 0
        self.Data = ""
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteBYTE(data, self.SubType)
        data = CommFunc.WriteDWORD(data, self.PlayerID)
        data = CommFunc.WriteDWORD(data, self.DataLen)
        data = CommFunc.WriteString(data, self.DataLen, self.Data)
        return data

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

#------------------------------------------------------
#Íæ¼ÒµÇ½֪ͨµØͼÍæ¼Ò»ù±¾Êý¾Ý#tagMapServerPlayerLogin

class  tagMapServerPlayerLogin(Structure):
    Type = 0    #(BYTE Type)
    ServerRoleIndex = 0    #(DWORD ServerRoleIndex)
    SessionID = 0    #(DWORD SessionID)
    ClientIP = ""    #(char ClientIP[16])
    PlayerInfoPackLen = 0    #(DWORD PlayerInfoPackLen)
    PlayerInfoPack = ""    #(String PlayerInfoPack)//size = PlayerInfoPackLen
    PlayerAccountInfoLen = 0    #(WORD PlayerAccountInfoLen)
    PlayerAccountInfo = ""    #(String PlayerAccountInfo)//size = PlayerAccountInfoLen
    MapID = 0    #(DWORD MapID)
    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.ServerRoleIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.SessionID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ClientIP,_pos = CommFunc.ReadString(_lpData, _pos,16)
        self.PlayerInfoPackLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PlayerInfoPack,_pos = CommFunc.ReadString(_lpData, _pos,self.PlayerInfoPackLen)
        self.PlayerAccountInfoLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PlayerAccountInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.PlayerAccountInfoLen)
        self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Type = 0
        self.ServerRoleIndex = 0
        self.SessionID = 0
        self.ClientIP = ""
        self.PlayerInfoPackLen = 0
        self.PlayerInfoPack = ""
        self.PlayerAccountInfoLen = 0
        self.PlayerAccountInfo = ""
        self.MapID = 0
        return

    def GetLength(self):
        length = 0
        length += 1
        length += 4
        length += 4
        length += 16
        length += 4
        length += len(self.PlayerInfoPack)
        length += 2
        length += len(self.PlayerAccountInfo)
        length += 4

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteBYTE(data, self.Type)
        data = CommFunc.WriteDWORD(data, self.ServerRoleIndex)
        data = CommFunc.WriteDWORD(data, self.SessionID)
        data = CommFunc.WriteString(data, 16, self.ClientIP)
        data = CommFunc.WriteDWORD(data, self.PlayerInfoPackLen)
        data = CommFunc.WriteString(data, self.PlayerInfoPackLen, self.PlayerInfoPack)
        data = CommFunc.WriteWORD(data, self.PlayerAccountInfoLen)
        data = CommFunc.WriteString(data, self.PlayerAccountInfoLen, self.PlayerAccountInfo)
        data = CommFunc.WriteDWORD(data, self.MapID)
        return data

    def OutputString(self):
        DumpString = '''
                                Type:%d,
                                ServerRoleIndex:%d,
                                SessionID:%d,
                                ClientIP:%s,
                                PlayerInfoPackLen:%d,
                                PlayerInfoPack:%s,
                                PlayerAccountInfoLen:%d,
                                PlayerAccountInfo:%s,
                                MapID:%d
                                '''\
                                %(
                                self.Type,
                                self.ServerRoleIndex,
                                self.SessionID,
                                self.ClientIP,
                                self.PlayerInfoPackLen,
                                self.PlayerInfoPack,
                                self.PlayerAccountInfoLen,
                                self.PlayerAccountInfo,
                                self.MapID
                                )
        return DumpString


#-----------------------------------------------------------------------------------------------------------    
    
import binascii
from Common import (mylog, )  

def test_tagServerGroupVersions():
    obj1 = tagServerGroupVersions()
    print 'sizeof(obj1) = %s'%obj1.GetLength()
    print 'obj1.OutputString() = %s'%obj1.OutputString()
    
    obj2 = tagServerGroupVersions()
    obj2.Type = 1
    obj2.VersionCnt = 2
    VersionList = []
#    obj2.setVersionCnt(2)
#    resize(obj2.VersionList, sizeof(tagServerGroupVersion) * obj2.VersionCnt)
    for i in xrange(obj2.VersionCnt):
        version = tagServerGroupVersion()
        version.MajorVersion = 3 + i
        version.MinorVersion = 4 + i
        version.LanguageVersion = 5 + i
        VersionList.append(version)
    obj2.VersionList = (tagServerGroupVersion * obj2.VersionCnt)(*VersionList) 
    print 'obj2.OutputString() = %s'%obj2.OutputString()
    
    pos = 0
    obj1.ReadData(obj2.GetBuffer(), pos, obj2.GetLength())
    print 'obj1.OutputString() = %s'%obj1.OutputString()
                  
def test():
        mylog.InitMyLog('test_SendPackProtocol.log')
        
        xDServerValueType = tagDServerValueType()
        mylog.info('init %s'%xDServerValueType.outputString())
        
        mylog.info('xDServerValueType.getLength() = %s'%xDServerValueType.getLength())
        
        xDServerValueType.Type = 1
        xDServerValueType.Value = 2
        mylog.info('buf = %s'%binascii.b2a_hex(xDServerValueType.getBuffer()))
        
        xDServerValueType1 = tagDServerValueType()
        mylog.info('init %s'%xDServerValueType1.outputString())
        pos = 0
        readLen = xDServerValueType1.readData(xDServerValueType.getBuffer(), pos, xDServerValueType.getLength())
        if readLen <= 0:
            mylog.error('error in readData')
            return
        mylog.info('readLen = %s'%readLen)
        mylog.info('after readData:%s'%xDServerValueType1.outputString())
    
if __name__ == '__main__':
#    test()
    test_tagServerGroupVersions()