#!/usr/bin/python
# -*- coding: GBK -*-
#´Ë´¦·â°üΪC++¶¨Òå·â°ü£¬ÓÃÄĸö°ü×ÔÈ¡£¬²»ÐèҪȫ²¿

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
#------------------------------------------------------
#06 04 ¼¼Äܹ¥»÷ʹÓóɹ¦#tagUseSkillAttack

class  tagSkillHurtObj(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ObjType", c_ubyte),    
                  ("ObjID", c_int),    
                  ("AttackType", c_ubyte),    #±¬»÷, miss
                  ("HurtHP", c_int),    
                  ("CurHP", c_int),    
                  ("CurHPEx", c_int),    
                  ]

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

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

    def Clear(self):
        self.ObjType = 0
        self.ObjID = 0
        self.AttackType = 0
        self.HurtHP = 0
        self.CurHP = 0
        self.CurHPEx = 0
        return

    def GetLength(self):
        return sizeof(tagSkillHurtObj)

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

    def OutputString(self):
        DumpString = '''//06 04 ¼¼Äܹ¥»÷ʹÓóɹ¦//tagUseSkillAttack:
                                ObjType:%d,
                                ObjID:%d,
                                AttackType:%d,
                                HurtHP:%d,
                                CurHP:%d,
                                CurHPEx:%d
                                '''\
                                %(
                                self.ObjType,
                                self.ObjID,
                                self.AttackType,
                                self.HurtHP,
                                self.CurHP,
                                self.CurHPEx
                                )
        return DumpString


class  tagUseSkillAttack(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    ObjType = 0    #(BYTE ObjType)
    BattleType = 0    #(BYTE BattleType)//ÎïÀí/ħ·¨
    SkillID = 0    #(WORD SkillID)
    AttackID = 0    #(DWORD AttackID)//Ö÷¹¥»÷Ä¿±ê
    AttackObjType = 0    #(BYTE AttackObjType)//Ö÷¹¥»÷Ä¿±ê
    HurtCount = 0    #(WORD HurtCount)//É˺¦ÊýÄ¿
    HurtList = list()    #(vector<tagSkillHurtObj> HurtList)//size = HurtCount
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ObjType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.BattleType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SkillID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.AttackID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.AttackObjType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.HurtCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.HurtCount):
            temHurtList = tagSkillHurtObj()
            _pos = temHurtList.ReadData(_lpData, _pos)
            self.HurtList.append(temHurtList)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x06
        self.Head.SubCmd = 0x04
        self.ObjID = 0
        self.ObjType = 0
        self.BattleType = 0
        self.SkillID = 0
        self.AttackID = 0
        self.AttackObjType = 0
        self.HurtCount = 0
        self.HurtList = list()
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteBYTE(data, self.ObjType)
        data = CommFunc.WriteBYTE(data, self.BattleType)
        data = CommFunc.WriteWORD(data, self.SkillID)
        data = CommFunc.WriteDWORD(data, self.AttackID)
        data = CommFunc.WriteBYTE(data, self.AttackObjType)
        data = CommFunc.WriteWORD(data, self.HurtCount)
        for i in range(self.HurtCount):
            data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                ObjType:%d,
                                BattleType:%d,
                                SkillID:%d,
                                AttackID:%d,
                                AttackObjType:%d,
                                HurtCount:%d,
                                HurtList:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.ObjType,
                                self.BattleType,
                                self.SkillID,
                                self.AttackID,
                                self.AttackObjType,
                                self.HurtCount,
                                "..."
                                )
        return DumpString


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

#06 14 ¶ÔµØÃæµÄ¼¼ÄÜʹÓóɹ¦#tagUseSkillPos

class  tagSkillPosHurtObj(Structure):
    _pack_ = 1
    _fields_ = [
                  ("ObjType", c_ubyte),    
                  ("ObjID", c_int),    
                  ("AttackType", c_ubyte),    #±¬»÷, miss
                  ("HurtHP", c_int),    
                  ("HurtHPEx", c_int),    
                  ("CurHP", c_int),    
                  ("CurHPEx", c_int),    
                  ]

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

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

    def Clear(self):
        self.ObjType = 0
        self.ObjID = 0
        self.AttackType = 0
        self.HurtHP = 0
        self.HurtHPEx = 0
        self.CurHP = 0
        self.CurHPEx = 0
        return

    def GetLength(self):
        return sizeof(tagSkillPosHurtObj)

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

    def OutputString(self):
        DumpString = '''//06 14 ¶ÔµØÃæµÄ¼¼ÄÜʹÓóɹ¦//tagUseSkillPos:
                                ObjType:%d,
                                ObjID:%d,
                                AttackType:%d,
                                HurtHP:%d,
                                HurtHPEx:%d,
                                CurHP:%d,
                                CurHPEx:%d
                                '''\
                                %(
                                self.ObjType,
                                self.ObjID,
                                self.AttackType,
                                self.HurtHP,
                                self.HurtHPEx,
                                self.CurHP,
                                self.CurHPEx
                                )
        return DumpString


class  tagUseSkillPos(Structure):
    Head = tagHead()
    ObjID = 0    #(DWORD ObjID)
    ObjType = 0    #(BYTE ObjType)
    BattleType = 0    #(BYTE BattleType)//ÎïÀí/ħ·¨
    SkillID = 0    #(WORD SkillID)
    PosX = 0    #(WORD PosX)
    PosY = 0    #(WORD PosY)
    HurtCount = 0    #(WORD HurtCount)//É˺¦ÊýÄ¿
    HurtList = list()    #(vector<tagSkillPosHurtObj> HurtList)//size = HurtCount
    SkillElementID = 0    #(WORD SkillElementID)//ר¾«¼¼ÄÜID    
    data = None

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

    def ReadData(self, _lpData, _pos=0, _Len=0):
        self.Clear()
        _pos = self.Head.ReadData(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.ObjType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.BattleType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.SkillID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.HurtCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
        for i in range(self.HurtCount):
            temHurtList = tagSkillPosHurtObj()
            _pos = temHurtList.ReadData(_lpData, _pos)
            self.HurtList.append(temHurtList)
        self.SkillElementID,_pos = CommFunc.ReadWORD(_lpData, _pos)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x06
        self.Head.SubCmd = 0x14
        self.ObjID = 0
        self.ObjType = 0
        self.BattleType = 0
        self.SkillID = 0
        self.PosX = 0
        self.PosY = 0
        self.HurtCount = 0
        self.HurtList = list()
        self.SkillElementID = 0
        return

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

        return length

    def GetBuffer(self):
        data = ''
        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteBYTE(data, self.ObjType)
        data = CommFunc.WriteBYTE(data, self.BattleType)
        data = CommFunc.WriteWORD(data, self.SkillID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteWORD(data, self.HurtCount)
        for i in range(self.HurtCount):
            data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
        data = CommFunc.WriteWORD(data, self.SkillElementID)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                ObjID:%d,
                                ObjType:%d,
                                BattleType:%d,
                                SkillID:%d,
                                PosX:%d,
                                PosY:%d,
                                HurtCount:%d,
                                HurtList:%s,
                                SkillElementID:%d
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.ObjID,
                                self.ObjType,
                                self.BattleType,
                                self.SkillID,
                                self.PosX,
                                self.PosY,
                                self.HurtCount,
                                "...",
                                self.SkillElementID
                                )
        return DumpString


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

#06 12 ¸ù¾ÝÀàÐÍÇå¿Õ¶ÔÏóµÄbuff#tagClearObjBuff

class  tagClearObjBuff(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjType", c_ubyte),    
                  ("ObjID", c_int),    
                  ("BuffType", c_ubyte),    #buffÀàÐÍ
                  ]

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

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

    def Clear(self):
        self.Cmd = 0x06
        self.SubCmd = 0x12
        self.ObjType = 0
        self.ObjID = 0
        self.BuffType = 0
        return

    def GetLength(self):
        return sizeof(tagClearObjBuff)

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

    def OutputString(self):
        DumpString = '''//06 12 ¸ù¾ÝÀàÐÍÇå¿Õ¶ÔÏóµÄbuff//tagClearObjBuff:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjType:%d,
                                ObjID:%d,
                                BuffType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjType,
                                self.ObjID,
                                self.BuffType
                                )
        return DumpString


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

#06 05 ¶ÔÏóÔö¼ÓBuf#tagObjAddBuff

class  tagObjAddBuff(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjType", c_ubyte),    #buffµÄÊÜЧ¹ûÕß
                  ("ObjID", c_int),    
                  ("BuffType", c_ubyte),    #BuffÀàÐÍ  TBuffType
                  ("SkillID", c_ushort),    
                  ("LastTime", c_int),    
                  ("Value", c_int),    
                  ("Value1", c_int),    
                  ("Value2", c_int),    
                  ("Layer", c_ubyte),    #²ãÊý£¬²»ÐèҪĬÈÏ0
                  ("OwnerID", c_int),    # buffÀ´Ô´Õß
                  ("OwnerType", c_ubyte),    
                  ]

    def __init__(self):
        self.Clear()
        self.Cmd = 0x06
        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 = 0x06
        self.SubCmd = 0x05
        self.ObjType = 0
        self.ObjID = 0
        self.BuffType = 0
        self.SkillID = 0
        self.LastTime = 0
        self.Value = 0
        self.Value1 = 0
        self.Value2 = 0
        self.Layer = 0
        self.OwnerID = 0
        self.OwnerType = 0
        return

    def GetLength(self):
        return sizeof(tagObjAddBuff)

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

    def OutputString(self):
        DumpString = '''//06 05 ¶ÔÏóÔö¼ÓBuf//tagObjAddBuff:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjType:%d,
                                ObjID:%d,
                                BuffType:%d,
                                SkillID:%d,
                                LastTime:%d,
                                Value:%d,
                                Value1:%d,
                                Value2:%d,
                                Layer:%d,
                                OwnerID:%d,
                                OwnerType:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjType,
                                self.ObjID,
                                self.BuffType,
                                self.SkillID,
                                self.LastTime,
                                self.Value,
                                self.Value1,
                                self.Value2,
                                self.Layer,
                                self.OwnerID,
                                self.OwnerType
                                )
        return DumpString


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

#05 01 ¶ÔÏóÒƶ¯¿ªÊ¼ #tagObjMove

class  tagObjMove(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjID", c_int),    
                  ("ObjType", c_ubyte),    
                  ("MoveType", c_ubyte),    
                  ("Speed", c_ushort),    
                  ("StartPosX", c_ushort),    
                  ("StartPosY", c_ushort),    
                  ("DestPosX", c_ushort),    
                  ("DestPosY", c_ushort),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0x05
        self.SubCmd = 0x01
        self.ObjID = 0
        self.ObjType = 0
        self.MoveType = 0
        self.Speed = 0
        self.StartPosX = 0
        self.StartPosY = 0
        self.DestPosX = 0
        self.DestPosY = 0
        return

    def GetLength(self):
        return sizeof(tagObjMove)

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

    def OutputString(self):
        DumpString = '''//05 01 ¶ÔÏóÒƶ¯¿ªÊ¼ //tagObjMove:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjID:%d,
                                ObjType:%d,
                                MoveType:%d,
                                Speed:%d,
                                StartPosX:%d,
                                StartPosY:%d,
                                DestPosX:%d,
                                DestPosY:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjID,
                                self.ObjType,
                                self.MoveType,
                                self.Speed,
                                self.StartPosX,
                                self.StartPosY,
                                self.DestPosX,
                                self.DestPosY
                                )
        return DumpString


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

#04 01 ÈËÎïËùÔڵij¡¾°³õʼ»¯#tagPlayerMapInit

class  tagPlayerMapInit(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("MapID", c_int),    
                  ("PosX", c_ushort),    
                  ("PosY", c_ushort),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0x04
        self.SubCmd = 0x01
        self.MapID = 0
        self.PosX = 0
        self.PosY = 0
        return

    def GetLength(self):
        return sizeof(tagPlayerMapInit)

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

    def OutputString(self):
        DumpString = '''//04 01 ÈËÎïËùÔڵij¡¾°³õʼ»¯//tagPlayerMapInit:
                                Cmd:%s,
                                SubCmd:%s,
                                MapID:%d,
                                PosX:%d,
                                PosY:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.MapID,
                                self.PosX,
                                self.PosY
                                )
        return DumpString


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

#01 09 ·þÎñÆ÷×¼±¸¾ÍÐ÷#tagServerPrepareOK

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

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

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

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

    def GetLength(self):
        return sizeof(tagServerPrepareOK)

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

    def OutputString(self):
        DumpString = '''//01 09 ·þÎñÆ÷×¼±¸¾ÍÐ÷//tagServerPrepareOK:
                                Cmd:%s,
                                SubCmd:%s,
                                Type:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.Type
                                )
        return DumpString


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

#04 19 Íæ¼ÒÖØÉú#tagPlayerReborn

class  tagPlayerReborn(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("PlayerID", c_int),    
                  ("Type", c_ubyte),    #¸´»îÀàÐÍ
                  ("PosX", c_ushort),    
                  ("PosY", c_ushort),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0x04
        self.SubCmd = 0x19
        self.PlayerID = 0
        self.Type = 0
        self.PosX = 0
        self.PosY = 0
        return

    def GetLength(self):
        return sizeof(tagPlayerReborn)

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

    def OutputString(self):
        DumpString = '''//04 19 Íæ¼ÒÖØÉú//tagPlayerReborn:
                                Cmd:%s,
                                SubCmd:%s,
                                PlayerID:%d,
                                Type:%d,
                                PosX:%d,
                                PosY:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.PlayerID,
                                self.Type,
                                self.PosX,
                                self.PosY
                                )
        return DumpString


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

#04 18 ÖÜΧ¶ÔÏóË¢ÐÂ#tagObjInfoRefresh

class  tagObjInfoRefresh(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjID", c_int),    
                  ("ObjType", c_ubyte),    
                  ("RefreshType", c_ubyte),    
                  ("Value", c_int),    
                  ]

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

    def 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 = 0x18
        self.ObjID = 0
        self.ObjType = 0
        self.RefreshType = 0
        self.Value = 0
        return

    def GetLength(self):
        return sizeof(tagObjInfoRefresh)

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

    def OutputString(self):
        DumpString = '''//04 18 ÖÜΧ¶ÔÏóË¢ÐÂ//tagObjInfoRefresh:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjID:%d,
                                ObjType:%d,
                                RefreshType:%d,
                                Value:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjID,
                                self.ObjType,
                                self.RefreshType,
                                self.Value
                                )
        return DumpString


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

#04 08 Íæ¼ÒÕÙ»½NPC³öÏÖ#tagPlayerSummonNPCAppear

class  tagPlayerSummonNPCAppear(Structure):
    Head = tagHead()
    PlayerID = 0    #(DWORD PlayerID)
    Country = 0    #(BYTE Country)
    ObjID = 0    #(DWORD ObjID)//ÕÙ»½³öÀ´µÄNPCID
    NPCID = 0    #(DWORD NPCID)
    PosX = 0    #(WORD PosX)
    PosY = 0    #(WORD PosY)
    HP = 0    #(DWORD HP)
    HPEx = 0    #(DWORD HPEx)
    MaxHP = 0    #(DWORD MaxHP)
    MaxHPEx = 0    #(DWORD MaxHPEx)
    Speed = 0    #(WORD Speed)
    LV = 0    #(WORD LV)
    OwnerNameLen = 0    #(BYTE OwnerNameLen)
    OwnerName = ""    #(String OwnerName)//size = OwnerNameLen
    data = None

    def __init__(self):
        self.Clear()
        self.Head.Cmd = 0x04
        self.Head.SubCmd = 0x08
        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.Country,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.ObjID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.NPCID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.PosX,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.PosY,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.HP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.HPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.MaxHPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
        self.Speed,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
        self.OwnerNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
        self.OwnerName,_pos = CommFunc.ReadString(_lpData, _pos,self.OwnerNameLen)
        return _pos

    def Clear(self):
        self.Head = tagHead()
        self.Head.Clear()
        self.Head.Cmd = 0x04
        self.Head.SubCmd = 0x08
        self.PlayerID = 0
        self.Country = 0
        self.ObjID = 0
        self.NPCID = 0
        self.PosX = 0
        self.PosY = 0
        self.HP = 0
        self.HPEx = 0
        self.MaxHP = 0
        self.MaxHPEx = 0
        self.Speed = 0
        self.LV = 0
        self.OwnerNameLen = 0
        self.OwnerName = ""
        return

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

        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.Country)
        data = CommFunc.WriteDWORD(data, self.ObjID)
        data = CommFunc.WriteDWORD(data, self.NPCID)
        data = CommFunc.WriteWORD(data, self.PosX)
        data = CommFunc.WriteWORD(data, self.PosY)
        data = CommFunc.WriteDWORD(data, self.HP)
        data = CommFunc.WriteDWORD(data, self.HPEx)
        data = CommFunc.WriteDWORD(data, self.MaxHP)
        data = CommFunc.WriteDWORD(data, self.MaxHPEx)
        data = CommFunc.WriteWORD(data, self.Speed)
        data = CommFunc.WriteWORD(data, self.LV)
        data = CommFunc.WriteBYTE(data, self.OwnerNameLen)
        data = CommFunc.WriteString(data, self.OwnerNameLen, self.OwnerName)
        return data

    def OutputString(self):
        DumpString = '''
                                Head:%s,
                                PlayerID:%d,
                                Country:%d,
                                ObjID:%d,
                                NPCID:%d,
                                PosX:%d,
                                PosY:%d,
                                HP:%d,
                                HPEx:%d,
                                MaxHP:%d,
                                MaxHPEx:%d,
                                Speed:%d,
                                LV:%d,
                                OwnerNameLen:%d,
                                OwnerName:%s
                                '''\
                                %(
                                self.Head.OutputString(),
                                self.PlayerID,
                                self.Country,
                                self.ObjID,
                                self.NPCID,
                                self.PosX,
                                self.PosY,
                                self.HP,
                                self.HPEx,
                                self.MaxHP,
                                self.MaxHPEx,
                                self.Speed,
                                self.LV,
                                self.OwnerNameLen,
                                self.OwnerName
                                )
        return DumpString


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

#06 08 NPCËÀÍö#tagNPCDie

class  tagNPCDie(Structure):
    _pack_ = 1
    _fields_ = [
                  ("Cmd", c_ubyte),
                  ("SubCmd", c_ubyte),
                  ("ObjID", c_int),    
                  ("Reason", c_int),    
                  ("KillerType", c_ubyte),    
                  ("KillerID", c_int),    
                  ]

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

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

    def Clear(self):
        self.Cmd = 0x06
        self.SubCmd = 0x08
        self.ObjID = 0
        self.Reason = 0
        self.KillerType = 0
        self.KillerID = 0
        return

    def GetLength(self):
        return sizeof(tagNPCDie)

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

    def OutputString(self):
        DumpString = '''//06 08 NPCËÀÍö//tagNPCDie:
                                Cmd:%s,
                                SubCmd:%s,
                                ObjID:%d,
                                Reason:%d,
                                KillerType:%d,
                                KillerID:%d
                                '''\
                                %(
                                self.Cmd,
                                self.SubCmd,
                                self.ObjID,
                                self.Reason,
                                self.KillerType,
                                self.KillerID
                                )
        return DumpString


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