#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
#
|
|
#½ÓÊÕ·â°üÐÒéF
|
#ʹÓÃProtocolStudio.CodeMaker.ÆÕͨ.NewParseNetPackStruct.pyÉú³É
|
#Éú³ÉµÄ´úÂë²»ÄÜEclipseÖ±½Ó±£´æ£¬ÒªÍ¨¹ýUE»òÆäËû±à¼Æ÷±£´æ£¬·ñÔò»áÌáʾ±àÂëÎÊÌâ
|
|
from ctypes import (Structure, c_ubyte, c_ushort, c_int, c_ulong, memset, addressof, sizeof, create_string_buffer,
|
memmove, string_at, c_double, c_char, POINTER, c_char_p)
|
from Common import (CommFunc, mylog)
|
|
from PackCommonDef import tagHead
|
|
#Êý¾Ý¿â³õʼ»¯²Ù×÷#tagDataServerInit
|
|
class tagDataServerInit(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(tagDataServerInit)
|
|
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 = '''//Êý¾Ý¿â³õʼ»¯²Ù×÷//tagDataServerInit:
|
Type:%d
|
'''\
|
%(
|
self.Type
|
)
|
return DumpString
|
|
#»ñÈ¡ÓïÑÔ°æ±¾#tagReqServerVersion
|
|
class tagReqServerVersion(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("MapServerIndex", 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
|
return
|
|
def GetLength(self):
|
return sizeof(tagReqServerVersion)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 5)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//»ñÈ¡ÓïÑÔ°æ±¾//tagReqServerVersion:
|
Type:%d,
|
MapServerIndex:%d
|
'''\
|
%(
|
self.Type,
|
self.MapServerIndex
|
)
|
return DumpString
|
|
#05 µÃµ½ÓÎÏ·Êý¾Ý#tagGSGetGameData
|
|
class tagGSGetGameData(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", 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.MapID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagGSGetGameData)
|
|
def GetBuffer(self):
|
return string_at(addressof(self), self.GetLength())
|
|
def OutputString(self):
|
DumpString = '''//05 µÃµ½ÓÎÏ·Êý¾Ý//tagGSGetGameData:
|
Type:%d,
|
MapID:%d
|
'''\
|
%(
|
self.Type,
|
self.MapID
|
)
|
return DumpString
|
|
|
|
#ÊÖд
|
class tagGDMapServerState(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('MapID', c_ulong),
|
('State', c_ubyte),
|
('RefreshTime', c_double),
|
('MapServerNumber', c_ubyte),
|
('IP', c_char * 30)
|
]
|
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, len = 0):
|
memmove(addressof(self), buf[pos:], self.getLength())
|
return pos + self.getLength()
|
|
def clear(self):
|
memset(addressof(self), 0, self.getLength())
|
|
def getLength(self):
|
return sizeof(self)
|
|
def getBuffer(self):
|
bufLen = self.getLength()
|
buf = create_string_buffer(bufLen)
|
pBuf = addressof(buf)
|
memmove(pBuf, addressof(self), bufLen)
|
return string_at(pBuf, bufLen)
|
|
def outputString(self):
|
return '''//·þÎñÆ÷״̬#tagGDServerState
|
MapID:%d,
|
State:%d,
|
RefreshTime:%f,
|
MapServerNumber:%d,
|
IP:%s'''\
|
%(
|
self.MapID,
|
self.State,
|
self.RefreshTime,
|
self.MapServerNumber,
|
self.IP
|
)
|
|
class tagGDServerState(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('Type', c_ubyte),
|
('MapCnt', c_ushort),
|
('MapServer', POINTER(tagGDMapServerState))
|
]
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, len = 0):
|
self.Type, pos = CommFunc.ReadBYTE(buf, pos)
|
self.MapCnt, pos = CommFunc.ReadWORD(buf, pos)
|
MapServer = []
|
for i in xrange(self.MapCnt):
|
value = tagGDMapServerState()
|
pos = value.readData(buf, pos)
|
MapServer.append(value)
|
self.MapServer = (tagGDMapServerState * self.MapCnt)(*MapServer)
|
return pos
|
|
def clear(self):
|
self.Type = 0
|
self.MapCnt = 0
|
self.MapServer = None
|
|
def getLength(self):
|
return sizeof(self) - sizeof(self.MapServer) + self.MapCnt * sizeof(tagGDMapServerState)
|
|
def getBuffer(self):
|
selfLength = self.getLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 3)
|
addrOfBuf += 3
|
for i in xrange(self.MapCnt):
|
length = self.MapServer[i].getLength()
|
memmove(addrOfBuf, self.MapServer[i].getBuffer(), length)
|
addrOfBuf += length
|
return string_at(addressof(buf), selfLength)
|
|
def outputString(self):
|
serverStateList = []
|
for i in xrange(self.MapCnt):
|
serverStateList.append(self.MapServer[i].outputString())
|
|
DumpString = '''//·þÎñÆ÷״̬//tagGDServerState:
|
Type:%d,
|
MapCnt:%d,
|
MapServer:%s
|
'''\
|
%(
|
self.Type,
|
self.MapCnt,
|
";".join(serverStateList)
|
)
|
return DumpString
|
|
#´Ë½á¹¹ÌåÄ¿Ç°²»ÄÜ×Ô¶¯Éú³É´úÂë
|
class tagMapServerPlayerSaveStream(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('Len', c_ulong),
|
('Data', POINTER(c_char))
|
]
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, len = 0):
|
self.clear()
|
self.Len, pos = CommFunc.ReadDWORD(buf, pos)
|
data, pos = CommFunc.ReadString(buf, pos, self.Len)
|
self.Data = (c_char * self.Len)(*data)
|
return pos
|
|
def clear(self):
|
self.Len = c_ulong(0)
|
self.Data = (c_char * 0)()
|
|
def getLength(self):
|
return sizeof(c_ulong) + self.Len
|
|
def getBuffer(self):
|
buf = ''
|
buf = CommFunc.WriteDWORD(buf, self.Len)
|
if self.Data and self.Len:
|
buf += string_at(self.Data, self.Len)
|
return buf
|
|
def outputString(self):
|
data = ''
|
if self.data and self.Len:
|
data = string_at(self.Data, self.Len
|
)
|
DumpString = '''Íæ¼Ò±£´æÄÚ´æÁ÷Êý¾Ý#tagMDSaveMapServerCrashData:Len: %s,Data:%s'''\
|
%(self.Len, binascii.b2a_hex(data))
|
return DumpString
|
|
class tagAllMapServerPlayerStreamData(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('Count', c_ushort),
|
('AllPlayerStream', POINTER(tagMapServerPlayerSaveStream))
|
]
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, len = 0):
|
self.clear()
|
self.Count, pos = CommFunc.ReadWORD(buf, pos)
|
itemList = []
|
for i in xrange(self.Count):
|
item = tagMapServerPlayerSaveStream()
|
pos = item.readData(buf, pos)
|
itemList.append(item)
|
self.AllPlayerStream = (tagMapServerPlayerSaveStream * self.Count)(*itemList)
|
return pos
|
|
def clear(self):
|
self.Count = 0
|
self.AllPlayerStream = None
|
|
def getLength(self):
|
length = sizeof(c_ushort)
|
for i in xrange(self.Count):
|
length += self.AllPlayerStream[i].getLength()
|
return length
|
|
def getBuffer(self):
|
buf = ''
|
buf = CommFunc.WriteWORD(buf, self.Count)
|
for i in xrange(self.Count):
|
buf += self.AllPlayerStream[i].getBuffer()
|
return buf
|
|
def outputString(self):
|
data = ''
|
for i in xrange(self.Count):
|
data += self.AllPlayerStream[i].getBuffer()
|
data = binascii.b2a_hex(data)
|
DumpString = '''Íæ¼Ò±£´æÄÚ´æÁ÷Êý¾Ý#tagAllMapServerPlayerStreamData: Count:%s, AllPlayerStream = %s'''\
|
%(self.Count, data)
|
return DumpString
|
|
class tagMapServerAllPlayerSaveStream(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('Mark', c_ushort),
|
('CRC', c_ulong),
|
('CRCCheckErrorServerType', c_ubyte),
|
('StreamData', tagAllMapServerPlayerStreamData)
|
]
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, length = 0):
|
self.Mark, pos = CommFunc.ReadWORD(buf, pos)
|
self.CRC, pos = CommFunc.ReadDWORD(buf, pos)
|
self.CRCCheckErrorServerType, pos = CommFunc.ReadBYTE(buf, pos)
|
pos = self.StreamData.readData(buf, pos)
|
return pos
|
|
def clear(self):
|
self.Mark = c_ushort(0)
|
self.CRC = c_ulong(0)
|
self.CRCCheckErrorServerType = c_ubyte(0)
|
self.StreamData.clear()
|
|
def getLength(self):
|
return sizeof(c_ushort) + sizeof(c_ulong) + sizeof(c_ubyte) + self.StreamData.getLength()
|
|
def getBuffer(self):
|
buf = ''
|
buf = CommFunc.WriteWORD(buf, self.Mark)
|
buf = CommFunc.WriteDWORD(buf, self.CRC)
|
buf = CommFunc.WriteBYTE(buf, self.CRCCheckErrorServerType)
|
buf += self.StreamData.getBuffer()
|
return buf
|
|
def outputString(self):
|
DumpString = '''//Íæ¼Ò±£´æÄÚ´æÁ÷Êý¾Ý#tagMapServerAllPlayerSaveStream:Mark:%s,
|
CRC:%s, CRCCheckErrorServerType:%s, StreamData:%s'''\
|
%(self.Mark, self.CRC, self.CRCCheckErrorServerType, self.StreamData.outputString())
|
return DumpString
|
|
class tagMDSaveMapServerCrashData(Structure):
|
_pack_ = 1
|
_fields_ = [
|
('Type', c_ubyte),
|
('SaveType', c_ubyte),
|
('NeedReturn', c_ubyte),
|
('VersionNO', c_ushort),
|
('MapID', c_ulong),
|
('SaveStream', tagMapServerAllPlayerSaveStream)
|
]
|
def __init__(self):
|
Structure.__init__(self)
|
self.clear()
|
|
def readData(self, buf, pos = 0, length = 0):
|
self.clear()
|
self.Type, pos = CommFunc.ReadBYTE(buf, pos)
|
self.SaveType, pos = CommFunc.ReadBYTE(buf, pos)
|
self.NeedReturn, pos = CommFunc.ReadBYTE(buf, pos)
|
self.VersionNO, pos = CommFunc.ReadWORD(buf, pos)
|
self.MapID, pos = CommFunc.ReadDWORD(buf, pos)
|
pos = self.SaveStream.readData(buf, pos)
|
return pos
|
|
def clear(self):
|
self.Type = c_ubyte(0)
|
self.SaveType = c_ubyte(0)
|
self.NeedReturn = c_ubyte(0)
|
self.VersionNO = c_ushort(0)
|
self.MapID = c_ulong(0)
|
self.SaveStream.clear()
|
|
def getLength(self):
|
return sizeof(c_ubyte) + sizeof(c_ubyte) + sizeof(c_ubyte) + sizeof(c_ushort) + sizeof(c_ulong) + self.SaveStream.getLength()
|
|
def getBuffer(self):
|
buf = ''
|
buf = CommFunc.WriteBYTE(buf, self.Type)
|
buf = CommFunc.WriteBYTE(buf, self.SaveType)
|
buf = CommFunc.WriteBYTE(buf, self.NeedReturn)
|
buf = CommFunc.WriteWORD(buf, self.VersionNO)
|
buf = CommFunc.WriteDWORD(buf, self.MapID)
|
buf += self.SaveStream.getBuffer()
|
return buf
|
|
def outputString(self):
|
DumpString = '''//Íæ¼Ò±£´æÄÚ´æÁ÷Êý¾Ý#tagMDSaveMapServerCrashData:Type:%s,
|
SaveType:%s, NeedReturn:%s, VersionNO:%s, MapID:%s, SaveStream:%s'''\
|
%(self.Type, self.SaveType, self.NeedReturn, self.VersionNO, self.MapID,
|
self.SaveStream.outputString())
|
return DumpString
|
|
#------------------------------------------------------
|
#01 ÈËÎïµÇ¼#tagDataServerPlayerLogin
|
|
class tagDataServerPlayerLogin(Structure):
|
Type = 0 #(BYTE Type)
|
AccID = "" #(char AccID[65])
|
ServerRoleIndex = 0 #(DWORD ServerRoleIndex)//ÔÚrouteÖеÄindex
|
SessionID = 0 #(DWORD SessionID)
|
Psw = "" #(char Psw[33])
|
AppID = "" #(char AppID[20])//Ó¦ÓñàÂë, ½ÓFreeSDK
|
AccountID = 0 #(DWORD AccountID)//Óû§IDÓëÕ˺Ų»Í¬£¬½ÓFreeSDK
|
TokenExpire = "" #(char TokenExpire[20])//ʱ¼ä´Á£¬ºÁÃ뼶£¬½ÓFreeSDK
|
Phone = 0 #(BYTE Phone)//ÊÇ·ñ°ó¶¨ÊÖ»ú
|
IDType = 0 #(BYTE IDType)//Õ˺ÅÀàÐÍ.0:ÆÕͨÕ˺Å;1:FreeSDK;
|
IP = "" #(char IP[20])
|
Adult = 0 #(BYTE Adult)//ÊÇ·ñ³ÉÄêÈË
|
ExtraLen = 0 #(WORD ExtraLen)//À©Õ¹³¤¶È
|
Extra = "" #(String Extra)//À©Õ¹ÄÚÈÝ£¬¸ù¾Ý²»Í¬Æ½Ì¨¶ø¶¨
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.ServerRoleIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.SessionID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Psw,_pos = CommFunc.ReadString(_lpData, _pos,33)
|
self.AppID,_pos = CommFunc.ReadString(_lpData, _pos,20)
|
self.AccountID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.TokenExpire,_pos = CommFunc.ReadString(_lpData, _pos,20)
|
self.Phone,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.IDType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.IP,_pos = CommFunc.ReadString(_lpData, _pos,20)
|
self.Adult,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ExtraLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.Extra,_pos = CommFunc.ReadString(_lpData, _pos,self.ExtraLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
self.ServerRoleIndex = 0
|
self.SessionID = 0
|
self.Psw = ""
|
self.AppID = ""
|
self.AccountID = 0
|
self.TokenExpire = ""
|
self.Phone = 0
|
self.IDType = 0
|
self.IP = ""
|
self.Adult = 0
|
self.ExtraLen = 0
|
self.Extra = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
length += 4
|
length += 4
|
length += 33
|
length += 20
|
length += 4
|
length += 20
|
length += 1
|
length += 1
|
length += 20
|
length += 1
|
length += 2
|
length += len(self.Extra)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteDWORD(data, self.ServerRoleIndex)
|
data = CommFunc.WriteDWORD(data, self.SessionID)
|
data = CommFunc.WriteString(data, 33, self.Psw)
|
data = CommFunc.WriteString(data, 20, self.AppID)
|
data = CommFunc.WriteDWORD(data, self.AccountID)
|
data = CommFunc.WriteString(data, 20, self.TokenExpire)
|
data = CommFunc.WriteBYTE(data, self.Phone)
|
data = CommFunc.WriteBYTE(data, self.IDType)
|
data = CommFunc.WriteString(data, 20, self.IP)
|
data = CommFunc.WriteBYTE(data, self.Adult)
|
data = CommFunc.WriteWORD(data, self.ExtraLen)
|
data = CommFunc.WriteString(data, self.ExtraLen, self.Extra)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s,
|
ServerRoleIndex:%d,
|
SessionID:%d,
|
Psw:%s,
|
AppID:%s,
|
AccountID:%d,
|
TokenExpire:%s,
|
Phone:%d,
|
IDType:%d,
|
IP:%s,
|
Adult:%d,
|
ExtraLen:%d,
|
Extra:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID,
|
self.ServerRoleIndex,
|
self.SessionID,
|
self.Psw,
|
self.AppID,
|
self.AccountID,
|
self.TokenExpire,
|
self.Phone,
|
self.IDType,
|
self.IP,
|
self.Adult,
|
self.ExtraLen,
|
self.Extra
|
)
|
return DumpString
|
|
|
#02 ÒªÇóÈ¡µÃÍæ¼ÒÏêϸÐÅÏ¢#tagPlayerDetailReq
|
|
class tagPlayerDetailReq(Structure):
|
Type = 0 #(BYTE Type)
|
AccID = "" #(char AccID[65])
|
IP = "" #(char IP[20])//怬IP
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.IP,_pos = CommFunc.ReadString(_lpData, _pos,20)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
self.IP = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
length += 20
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteString(data, 20, self.IP)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s,
|
IP:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID,
|
self.IP
|
)
|
return DumpString
|
|
#·þÎñÆ÷ÈÕÖ¾¼Ç¼#tagDBServerLogRec
|
|
class tagDBServerLogRec(Structure):
|
Type = 0 #(BYTE Type)
|
Oper = 0 #(WORD Oper)
|
Time = 0 #(double Time)
|
MapID = 0 #(WORD MapID)
|
PlayerID = 0 #(DWORD PlayerID)
|
TagID = 0 #(DWORD TagID)
|
Par = 0 #(DWORD Par)
|
MsgLen = 0 #(WORD MsgLen)
|
Msg = "" #(String Msg)//size = MsgLen
|
ExData1 = 0 #(BYTE ExData1)//À©Õ¹×Ö¶Î1
|
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.Oper,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.Time,_pos = CommFunc.ReadDouble(_lpData, _pos)
|
self.MapID,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.TagID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Par,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MsgLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.Msg,_pos = CommFunc.ReadString(_lpData, _pos,self.MsgLen)
|
self.ExData1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.Oper = 0
|
self.Time = 0
|
self.MapID = 0
|
self.PlayerID = 0
|
self.TagID = 0
|
self.Par = 0
|
self.MsgLen = 0
|
self.Msg = ""
|
self.ExData1 = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 2
|
length += 8
|
length += 2
|
length += 4
|
length += 4
|
length += 4
|
length += 2
|
length += len(self.Msg)
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteWORD(data, self.Oper)
|
data = CommFunc.WriteDouble(data, self.Time)
|
data = CommFunc.WriteWORD(data, self.MapID)
|
data = CommFunc.WriteDWORD(data, self.PlayerID)
|
data = CommFunc.WriteDWORD(data, self.TagID)
|
data = CommFunc.WriteDWORD(data, self.Par)
|
data = CommFunc.WriteWORD(data, self.MsgLen)
|
data = CommFunc.WriteString(data, self.MsgLen, self.Msg)
|
data = CommFunc.WriteBYTE(data, self.ExData1)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
Oper:%d,
|
Time:%s,
|
MapID:%d,
|
PlayerID:%d,
|
TagID:%d,
|
Par:%d,
|
MsgLen:%d,
|
Msg:%s,
|
ExData1:%d
|
'''\
|
%(
|
self.Type,
|
self.Oper,
|
self.Time,
|
self.MapID,
|
self.PlayerID,
|
self.TagID,
|
self.Par,
|
self.MsgLen,
|
self.Msg,
|
self.ExData1
|
)
|
return DumpString
|
|
|
|
#(null)#tagGBGetGameServerPlayerLoginData
|
|
class tagGBGetGameServerPlayerLoginData(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("PlayerID", 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.PlayerID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagGBGetGameServerPlayerLoginData)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 5)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//(null)//tagGBGetGameServerPlayerLoginData:
|
Type:%d,
|
PlayerID:%d
|
'''\
|
%(
|
self.Type,
|
self.PlayerID
|
)
|
return DumpString
|
|
#(null)#tagGameServerToBalanceServerPlayerSaveData
|
|
class tagGameServerToBalanceServerPlayerSaveData(Structure):
|
PackType = 0 #(BYTE PackType)
|
NeedReturn = 0 #(BYTE NeedReturn)
|
Type = 0 #(BYTE Type)
|
PlayerID = 0 #(DWORD PlayerID)
|
DataLen = 0 #(DWORD DataLen)
|
Data = "" #(String Data)//size = DataLen
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.PackType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.NeedReturn,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Type,_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.PackType = 0
|
self.NeedReturn = 0
|
self.Type = 0
|
self.PlayerID = 0
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += 4
|
length += 4
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.PackType)
|
data = CommFunc.WriteBYTE(data, self.NeedReturn)
|
data = CommFunc.WriteBYTE(data, self.Type)
|
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 = '''
|
PackType:%d,
|
NeedReturn:%d,
|
Type:%d,
|
PlayerID:%d,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.PackType,
|
self.NeedReturn,
|
self.Type,
|
self.PlayerID,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
#Íæ¼Ò¸öÈË×ÊÁϱ£´æ#tagGDSavePlayerInfo
|
|
class tagGDSavePlayerInfo(Structure):
|
Type = 0 #(BYTE Type)
|
AccID = "" #(char AccID[65])
|
GeTuiClientID = "" #(char GeTuiClientID[33])
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.GeTuiClientID,_pos = CommFunc.ReadString(_lpData, _pos,33)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
self.GeTuiClientID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
length += 33
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteString(data, 33, self.GeTuiClientID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s,
|
GeTuiClientID:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID,
|
self.GeTuiClientID
|
)
|
return DumpString
|
|
|
|
|
#ɾ³ýÎïÀí·ÖÁ÷ÐÅÏ¢#tagDBDelLineInfo
|
|
class tagDBDelLineInfo(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("LineID", c_int), #·ÖÁ÷ID
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.LineID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDBDelLineInfo)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 5)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//ɾ³ýÎïÀí·ÖÁ÷ÐÅÏ¢//tagDBDelLineInfo:
|
Type:%d,
|
LineID:%d
|
'''\
|
%(
|
self.Type,
|
self.LineID
|
)
|
return DumpString
|
|
|
#GMÃüÁî#tagGMCommand
|
|
class tagGMCommand(Structure):
|
Type = 0 #(BYTE Type)
|
ServerID = 0 #(DWORD ServerID)
|
OrderLen = 0 #(BYTE OrderLen)
|
OrderId = "" #(String OrderId)
|
CmdLen = 0 #(DWORD CmdLen)
|
Cmd = "" #(String Cmd)
|
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.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.OrderLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderId,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderLen)
|
self.CmdLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Cmd,_pos = CommFunc.ReadString(_lpData, _pos,self.CmdLen)
|
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.ServerID = 0
|
self.OrderLen = 0
|
self.OrderId = ""
|
self.CmdLen = 0
|
self.Cmd = ""
|
self.UserDataLen = 0
|
self.UserData = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += 1
|
length += len(self.OrderId)
|
length += 4
|
length += len(self.Cmd)
|
length += 4
|
length += len(self.UserData)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.ServerID)
|
data = CommFunc.WriteBYTE(data, self.OrderLen)
|
data = CommFunc.WriteString(data, self.OrderLen, self.OrderId)
|
data = CommFunc.WriteDWORD(data, self.CmdLen)
|
data = CommFunc.WriteString(data, self.CmdLen, self.Cmd)
|
data = CommFunc.WriteDWORD(data, self.UserDataLen)
|
data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
ServerID:%d,
|
OrderLen:%d,
|
OrderId:%s,
|
CmdLen:%d,
|
Cmd:%s,
|
UserDataLen:%d,
|
UserData:%s
|
'''\
|
%(
|
self.Type,
|
self.ServerID,
|
self.OrderLen,
|
self.OrderId,
|
self.CmdLen,
|
self.Cmd,
|
self.UserDataLen,
|
self.UserData
|
)
|
return DumpString
|
|
|
|
#GMÃüÁîÊý¾Ý¿âÇëÇó#tagGMCommandDBRequest
|
class tagGMCommandDBRequest(Structure):
|
Type = 0 #(BYTE Type)
|
OrderLen = 0 #(BYTE OrderLen)
|
OrderId = "" #(String OrderId)
|
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.OrderLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderId,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderLen)
|
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.OrderLen = 0
|
self.OrderId = ""
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += len(self.OrderId)
|
length += 4
|
length += len(self.Data)
|
|
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.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
OrderLen:%d,
|
OrderId:%s,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.OrderLen,
|
self.OrderId,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
#-------------------------------------------------------------------------
|
#tagMarkPlayerDeleted
|
|
class tagMarkPlayerDeleted(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("PlayerID", 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.PlayerID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagMarkPlayerDeleted)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 5)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''tagMarkPlayerDeleted:
|
Type:%d,
|
PlayerID:%d
|
'''\
|
%(
|
self.Type,
|
self.PlayerID
|
)
|
return DumpString
|
|
#Ë¢ÐÂGateServerÍâÍøIP#tagRefreshGateServerIP
|
|
class tagRefreshGateServerIP(Structure):
|
Type = 0 #(BYTE Type)
|
RefreshTime = 0 #(double RefreshTime)
|
RouteServerIndex = 0 #(BYTE RouteServerIndex)
|
LineNO = 0 #(DWORD LineNO)//_KEY_
|
GateServerIndex = 0 #(BYTE GateServerIndex)
|
Len = 0 #(WORD Len)// ip ³¤¶È
|
IP = "" #(String IP)// IPÄÚÈÝ
|
Port = 0 #(WORD Port)
|
CurPlayerCnt = 0 #(DWORD CurPlayerCnt)//µ±Ç°¸ºÔØÈËÊý
|
MaxPlayerCnt = 0 #(DWORD MaxPlayerCnt)//×î´ó¸ºÔØÈËÊý
|
LineType = 0 #(BYTE LineType)//·ÖÏßÀàÐÍ 0 - pc, 1 - mb
|
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.RefreshTime,_pos = CommFunc.ReadDouble(_lpData, _pos)
|
self.RouteServerIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.LineNO,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.GateServerIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.IP,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
|
self.Port,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.CurPlayerCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MaxPlayerCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.LineType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.RefreshTime = 0
|
self.RouteServerIndex = 0
|
self.LineNO = 0
|
self.GateServerIndex = 0
|
self.Len = 0
|
self.IP = ""
|
self.Port = 0
|
self.CurPlayerCnt = 0
|
self.MaxPlayerCnt = 0
|
self.LineType = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 8
|
length += 1
|
length += 4
|
length += 1
|
length += 2
|
length += len(self.IP)
|
length += 2
|
length += 4
|
length += 4
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDouble(data, self.RefreshTime)
|
data = CommFunc.WriteBYTE(data, self.RouteServerIndex)
|
data = CommFunc.WriteDWORD(data, self.LineNO)
|
data = CommFunc.WriteBYTE(data, self.GateServerIndex)
|
data = CommFunc.WriteWORD(data, self.Len)
|
data = CommFunc.WriteString(data, self.Len, self.IP)
|
data = CommFunc.WriteWORD(data, self.Port)
|
data = CommFunc.WriteDWORD(data, self.CurPlayerCnt)
|
data = CommFunc.WriteDWORD(data, self.MaxPlayerCnt)
|
data = CommFunc.WriteBYTE(data, self.LineType)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
RefreshTime:%s,
|
RouteServerIndex:%d,
|
LineNO:%d,
|
GateServerIndex:%d,
|
Len:%d,
|
IP:%s,
|
Port:%d,
|
CurPlayerCnt:%d,
|
MaxPlayerCnt:%d,
|
LineType:%d
|
'''\
|
%(
|
self.Type,
|
self.RefreshTime,
|
self.RouteServerIndex,
|
self.LineNO,
|
self.GateServerIndex,
|
self.Len,
|
self.IP,
|
self.Port,
|
self.CurPlayerCnt,
|
self.MaxPlayerCnt,
|
self.LineType
|
)
|
return DumpString
|
|
|
class tagBDStringTypeSend(Structure):
|
Type = 0 #(BYTE Type)
|
DataLen = 0 #(WORD DataLen)
|
Data = "" #(String Data)//size = DataLen
|
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.ReadWORD(_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 += 2
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteWORD(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
|
|
#¸ù¾ÝAccÕÒµ½ÖµtagDGetValueByAcc
|
|
class tagDGetValueByAcc(Structure):
|
Type = 0 #(BYTE Type)
|
AccLen = 0 #(BYTE AccLen)
|
Acc = "" #(String Acc)//size = AccLen
|
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.AccLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Acc,_pos = CommFunc.ReadString(_lpData, _pos,self.AccLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccLen = 0
|
self.Acc = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += len(self.Acc)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.AccLen)
|
data = CommFunc.WriteString(data, self.AccLen, self.Acc)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccLen:%d,
|
Acc:%s
|
'''\
|
%(
|
self.Type,
|
self.AccLen,
|
self.Acc
|
)
|
return DumpString
|
|
#»»µãȯtagMDCoinChangeReq
|
class tagMDCoinChangeReq(Structure):
|
Type = 0 #(BYTE Type)
|
PlayerID = 0 #(DWORD PlayerID)/¶Ò»»È˵ÄÍæ¼ÒID
|
AccLen = 0 #(BYTE AccLen)
|
Acc = "" #(String Acc)//size = AccLen
|
Coin = 0 #(DWORD Coin)
|
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.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.AccLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Acc,_pos = CommFunc.ReadString(_lpData, _pos,self.AccLen)
|
self.Coin,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.PlayerID = 0
|
self.AccLen = 0
|
self.Acc = ""
|
self.Coin = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += 1
|
length += len(self.Acc)
|
length += 4
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.PlayerID)
|
data = CommFunc.WriteBYTE(data, self.AccLen)
|
data = CommFunc.WriteString(data, self.AccLen, self.Acc)
|
data = CommFunc.WriteDWORD(data, self.Coin)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
PlayerID:%d,
|
AccLen:%d,
|
Acc:%s,
|
Coin:%d
|
'''\
|
%(
|
self.Type,
|
self.PlayerID,
|
self.AccLen,
|
self.Acc,
|
self.Coin
|
)
|
return DumpString
|
|
|
#֪ͨDBÍê³É³äÖµ¶Ò»» #tagMDFinishRecharge
|
|
class tagMDFinishRecharge(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
OrderIDLen = 0 #(BYTE OrderIDLen)
|
OrderID = "" #(String OrderID)
|
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)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.OrderIDLen = 0
|
self.OrderID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.OrderID)
|
|
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)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
OrderIDLen:%d,
|
OrderID:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.OrderIDLen,
|
self.OrderID
|
)
|
return DumpString
|
|
|
#²éѯÊÇ·ñÓÐеijäÖµ¶©µ¥ #tagMDQueryRecharge
|
|
class tagMDQueryRecharge(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
Account = "" #(char Account[65])//ÕʺÅ
|
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.Account,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.Account = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 65
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.SubType)
|
data = CommFunc.WriteString(data, 65, self.Account)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
Account:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.Account
|
)
|
return DumpString
|
|
|
|
#²éѯÐÂÊÖýÌ忨ÊÇ·ñÒÑʹÓÃ#tagMDIsMediaCardUsed
|
|
class tagMDIsMediaCardUsed(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
CardIDLen = 0 #(BYTE CardIDLen)
|
CardID = "" #(String CardID)// size = CardIDLen
|
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)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.CardIDLen = 0
|
self.CardID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.CardID)
|
|
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)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
CardIDLen:%d,
|
CardID:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.CardIDLen,
|
self.CardID
|
)
|
return DumpString
|
|
|
#¸üÐÂýÌåÐÂÊÖ¿¨×´Ì¬#tagMDCheckUpdateMediaCardState
|
|
class tagMDCheckUpdateMediaCardState(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
|
|
|
|
#¼ì²éÓû§ÊÇ·ñ´æÔÚtagBDCheckNameExist
|
|
class tagBDCheckNameExist(Structure):
|
Type = 0 #(BYTE Type)
|
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.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.NameLen = 0
|
self.Name = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += len(self.Name)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.NameLen)
|
data = CommFunc.WriteString(data, self.NameLen, self.Name)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
NameLen:%d,
|
Name:%s
|
'''\
|
%(
|
self.Type,
|
self.NameLen,
|
self.Name
|
)
|
return DumpString
|
|
|
#È¡µÃÓʼþÁбíÇëÇótagDBGetMailListReq
|
|
class tagDBGetMailListReq(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("RouteServerIndex", c_int),
|
("PlayerID", 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.RouteServerIndex = 0
|
self.PlayerID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDBGetMailListReq)
|
|
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 = '''//tagDBGetMailListReq:
|
Type:%d,
|
RouteServerIndex:%d,
|
PlayerID:%d
|
'''\
|
%(
|
self.Type,
|
self.RouteServerIndex,
|
self.PlayerID
|
)
|
return DumpString
|
|
|
#tagDBGetMailDetailReq
|
|
class tagDBGetMailDetailReq(Structure):
|
Type = 0 #(BYTE Type)
|
MailID = "" #(char MailID[40])
|
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.MailID,_pos = CommFunc.ReadString(_lpData, _pos,40)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.MailID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 40
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 40, self.MailID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
MailID:%s
|
'''\
|
%(
|
self.Type,
|
self.MailID
|
)
|
return DumpString
|
|
|
#ɾ³ýÓʼþÇëÇó#tagDBDeleteMail
|
|
class tagDBDeleteMail(Structure):
|
Type = 0 #(BYTE Type)
|
MailID = "" #(char MailID[40])
|
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.MailID,_pos = CommFunc.ReadString(_lpData, _pos,40)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.MailID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 40
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 40, self.MailID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
MailID:%s
|
'''\
|
%(
|
self.Type,
|
self.MailID
|
)
|
return DumpString
|
|
#¸üÐÂÓʼþÐÅÏ¢#tagDBUpdateMail
|
|
class tagDBUpdateMail(Structure):
|
Type = 0 #(BYTE Type)
|
MailID = "" #(char MailID[40])
|
UpdateMailType = 0 #(BYTE UpdateMailType)//ÊÇ·ñ¸üÐÂÓʼþÀàÐÍ
|
MailType = 0 #(BYTE MailType)//δ¶Á/ÒѶÁ/Òѱ£´æ
|
UpdateLetterType = 0 #(BYTE UpdateLetterType)//ÊÇ·ñ¸üÐÂÐżþÀàÐÍ
|
LetterType = 0 #(BYTE LetterType)
|
GetAllMoney = 0 #(BYTE GetAllMoney)//È¡µÃËùÓеÄÇ®
|
GetAllItem = 0 #(BYTE GetAllItem)//È¡µÃËùÓеÄÎïÆ·
|
ReturnMail = 0 #(BYTE ReturnMail)//ÍË»ØÐżþ
|
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.MailID,_pos = CommFunc.ReadString(_lpData, _pos,40)
|
self.UpdateMailType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.MailType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.UpdateLetterType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.LetterType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.GetAllMoney,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.GetAllItem,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ReturnMail,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.MailID = ""
|
self.UpdateMailType = 0
|
self.MailType = 0
|
self.UpdateLetterType = 0
|
self.LetterType = 0
|
self.GetAllMoney = 0
|
self.GetAllItem = 0
|
self.ReturnMail = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 40
|
length += 1
|
length += 1
|
length += 1
|
length += 1
|
length += 1
|
length += 1
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 40, self.MailID)
|
data = CommFunc.WriteBYTE(data, self.UpdateMailType)
|
data = CommFunc.WriteBYTE(data, self.MailType)
|
data = CommFunc.WriteBYTE(data, self.UpdateLetterType)
|
data = CommFunc.WriteBYTE(data, self.LetterType)
|
data = CommFunc.WriteBYTE(data, self.GetAllMoney)
|
data = CommFunc.WriteBYTE(data, self.GetAllItem)
|
data = CommFunc.WriteBYTE(data, self.ReturnMail)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
MailID:%s,
|
UpdateMailType:%d,
|
MailType:%d,
|
UpdateLetterType:%d,
|
LetterType:%d,
|
GetAllMoney:%d,
|
GetAllItem:%d,
|
ReturnMail:%d
|
'''\
|
%(
|
self.Type,
|
self.MailID,
|
self.UpdateMailType,
|
self.MailType,
|
self.UpdateLetterType,
|
self.LetterType,
|
self.GetAllMoney,
|
self.GetAllItem,
|
self.ReturnMail
|
)
|
return DumpString
|
|
#01 05 ¼ÓÐ鱦ÎïÆ·#tagIRAddItem
|
|
class tagIRAddItem(Structure):
|
Head = tagHead()
|
AccLen = 0 #(BYTE AccLen)
|
Acc = "" #(String Acc)//size = AccLen
|
ItemID = 0 #(DWORD ItemID)
|
ItemCnt = 0 #(DWORD ItemCnt)
|
IsBind = 0 #(BYTE IsBind)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x05
|
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.ItemCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.IsBind,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Head = tagHead()
|
self.Head.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x05
|
self.AccLen = 0
|
self.Acc = ""
|
self.ItemID = 0
|
self.ItemCnt = 0
|
self.IsBind = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += self.Head.GetLength()
|
length += 1
|
length += len(self.Acc)
|
length += 4
|
length += 4
|
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.WriteDWORD(data, self.ItemCnt)
|
data = CommFunc.WriteBYTE(data, self.IsBind)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Head:%s,
|
AccLen:%d,
|
Acc:%s,
|
ItemID:%d,
|
ItemCnt:%d,
|
IsBind:%d
|
'''\
|
%(
|
self.Head.OutputString(),
|
self.AccLen,
|
self.Acc,
|
self.ItemID,
|
self.ItemCnt,
|
self.IsBind
|
)
|
return DumpString
|
|
#ÁìÈ¡¶à¸ö²¹³¥#tagMDGetExpiationEx
|
|
class tagMDGetExpiationEx(Structure):
|
Type = 0 #(BYTE Type)
|
AccLen = 0 #(BYTE AccLen)
|
Acc = "" #(String Acc)//size = AccLen
|
Count = 0 #(BYTE Count)//ÁìÈ¡ÊýÁ¿
|
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.AccLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Acc,_pos = CommFunc.ReadString(_lpData, _pos,self.AccLen)
|
self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccLen = 0
|
self.Acc = ""
|
self.Count = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += len(self.Acc)
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.AccLen)
|
data = CommFunc.WriteString(data, self.AccLen, self.Acc)
|
data = CommFunc.WriteBYTE(data, self.Count)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccLen:%d,
|
Acc:%s,
|
Count:%d
|
'''\
|
%(
|
self.Type,
|
self.AccLen,
|
self.Acc,
|
self.Count
|
)
|
return DumpString
|
|
#ÇëÇóÍæ¼ÒÃûÊÇ·ñ´æÔÚ#tagCSCheckPlayerNameExist
|
|
class tagCSCheckPlayerNameExist(Structure):
|
Type = 0 #(BYTE Type)// ÇëÇóÀàÐÍ
|
AccID = "" #(char AccID[65])//ÕʺÅÃû, ¸Ã½ÇÉ«ËùÔÚµÄÕʺŵÄÓû§Ãû
|
PlayerName = "" #(char PlayerName[15])//½ÇÉ«Ãû£¬size = 14
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,15)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
self.PlayerName = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
length += 15
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteString(data, 15, self.PlayerName)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s,
|
PlayerName:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID,
|
self.PlayerName
|
)
|
return DumpString
|
|
|
##ÇëÇóÊÇ·ñÓÐÓÐЧ½ÇÉ«#tagCSIsHaveRole
|
|
class tagCSIsHaveRole(Structure):
|
Type = 0 #(BYTE Type)// ÇëÇóÀàÐÍ
|
AccID = "" #(char AccID[65])//ÕʺÅÃû, ¸Ã½ÇÉ«ËùÔÚµÄÕʺŵÄÓû§Ãû
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID
|
)
|
return DumpString
|
|
#ºÃÓÑɾ³ýKey#tagDeleteFriendKey
|
|
class tagDeleteFriendKey(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("PlayerID", c_int), #ÎïÆ·ID
|
("FriendID", c_int), #¹¦ÄÜÏî
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.PlayerID = 0
|
self.FriendID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDeleteFriendKey)
|
|
def GetBuffer(self):
|
return string_at(addressof(self), self.GetLength())
|
|
def OutputString(self):
|
DumpString = '''//ºÃÓÑɾ³ýKey//tagDeleteFriendKey:
|
PlayerID:%d,
|
FriendID:%d
|
'''\
|
%(
|
self.PlayerID,
|
self.FriendID
|
)
|
return DumpString
|
|
#GameServerͨÓÃÊý¾Ý¿â²Ù×÷#tagGDGameServerGeneralDBOper
|
|
class tagGDGameServerGeneralDBOper(Structure):
|
Type = 0 #(BYTE Type)//·â°üÀàÐÍ
|
NeedReturn = 0 #(BYTE NeedReturn)//ÊÇ·ñÐèÒª·µ»Ø
|
OperDictLen = 0 #(DWORD OperDictLen)
|
OperDict = "" #(String OperDict)//²Ù×÷×Öµä
|
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.NeedReturn,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OperDictLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.OperDict,_pos = CommFunc.ReadString(_lpData, _pos,self.OperDictLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.NeedReturn = 0
|
self.OperDictLen = 0
|
self.OperDict = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 4
|
length += len(self.OperDict)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.NeedReturn)
|
data = CommFunc.WriteDWORD(data, self.OperDictLen)
|
data = CommFunc.WriteString(data, self.OperDictLen, self.OperDict)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
NeedReturn:%d,
|
OperDictLen:%d,
|
OperDict:%s
|
'''\
|
%(
|
self.Type,
|
self.NeedReturn,
|
self.OperDictLen,
|
self.OperDict
|
)
|
return DumpString
|
|
#------------------------------------------------------
|
#GameSeverÏòDBÇëÇóÐÅÏ¢#tagGDGameServerToDBLogic
|
|
class tagGDGameServerToDBLogic(Structure):
|
Type = 0 #(BYTE Type)//·â°üÀàÐÍ
|
ID = 0 #(DWORD ID)//²éѯ¶ÔÏóID
|
QueryType = 0 #(BYTE QueryType)//²éѯʼþÀàÐÍ
|
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.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)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.ID = 0
|
self.QueryType = 0
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
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.ID)
|
data = CommFunc.WriteBYTE(data, self.QueryType)
|
data = CommFunc.WriteDWORD(data, self.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
ID:%d,
|
QueryType:%d,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.ID,
|
self.QueryType,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
#------------------------------------------------------
|
#ÏòÖ¸¶¨×Ó·þ·¢ËÍÏûÏ¢#tagGDMergeMsgToClient
|
|
class tagGDMergeMsgToClient(Structure):
|
Type = 0 #(BYTE Type)//ÀàÐÍ
|
GroupID = 0 #(DWORD GroupID)//×éID£¨Ó²¼þ£©
|
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.GroupID,_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.GroupID = 0
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += 4
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.GroupID)
|
data = CommFunc.WriteDWORD(data, self.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
GroupID:%d,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.GroupID,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
|
#------------------------------------------------------
|
#ÏòÖ¸¶¨×Ó·þ×é·¢ËÍÏûÏ¢ #tagGDMergeMsgToClientList
|
|
class tagGDMergeMsgToClientList(Structure):
|
Type = 0 #(BYTE Type)//ÀàÐÍ
|
GroupsLen = 0 #(DWORD GroupsLen)
|
Groups = "" #(String Groups)//·þÎñÆ÷×é
|
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.GroupsLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Groups,_pos = CommFunc.ReadString(_lpData, _pos,self.GroupsLen)
|
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.GroupsLen = 0
|
self.Groups = ""
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += len(self.Groups)
|
length += 4
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.GroupsLen)
|
data = CommFunc.WriteString(data, self.GroupsLen, self.Groups)
|
data = CommFunc.WriteDWORD(data, self.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
GroupsLen:%d,
|
Groups:%s,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.GroupsLen,
|
self.Groups,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
|
|
|
#¹ã²¥¿ç·þ¿Í»§¶Ë#tagGDBroadcastMergeClient
|
|
class tagGDBroadcastMergeClient(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
|
#GameServerÇëÇó¿ÉÓüÒ×åID#tagGDRequestCanUseFamilyIDList
|
|
class tagGDRequestCanUseFamilyIDList(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("CallType", c_ubyte), #0Ϊ³õʼ»¯ÇëÇó£¬1ΪÊýÁ¿²»×ãʱ²¹³äÇëÇó
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.CallType = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagGDRequestCanUseFamilyIDList)
|
|
def GetBuffer(self):
|
return string_at(addressof(self), self.GetLength())
|
|
def OutputString(self):
|
DumpString = '''//GameServerÇëÇó¿ÉÓüÒ×åID//tagGDRequestCanUseFamilyIDList:
|
Type:%d,
|
CallType:%d
|
'''\
|
%(
|
self.Type,
|
self.CallType
|
)
|
return DumpString
|
|
|
|
#------------------------------------------------------
|
#½øÈë´´½ÇÂñµã #tagLDPrepareCreateRole
|
|
class tagLDPrepareCreateRole(Structure):
|
Type = 0 #(BYTE Type)
|
AccID = "" #(char AccID[65])
|
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.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.AccID = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 65
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
AccID:%s
|
'''\
|
%(
|
self.Type,
|
self.AccID
|
)
|
return DumpString
|
|
|
#-----------------------------------------------------------------------------------------------------------
|
|
import binascii
|
from Common import (mylog, )
|
|
def test_tagMDSaveMapServerCrashData():
|
crashData = tagMDSaveMapServerCrashData()
|
print 'crashData.outputString() = %s'%crashData.outputString()
|
print 'crashData.getLength() = %s'%crashData.getLength()
|
print 'crashData.getBuffer() = %s'%binascii.b2a_hex(crashData.getBuffer())
|
|
crashData.Type = 1
|
crashData.SaveType = 2
|
crashData.NeedReturn = 3
|
crashData.VersionNO = 4
|
crashData.MapID = 5
|
|
saveStream = tagMapServerAllPlayerSaveStream()
|
saveStream.Mark = 0xFF88
|
saveStream.CRC = 123
|
saveStream.CRCCheckErrorServerType = 4
|
streamData = tagAllMapServerPlayerStreamData()
|
streamData.Count = 2
|
playerStreamList = []
|
for i in xrange(streamData.Count):
|
item = tagMapServerPlayerSaveStream()
|
item.Data = '%s'%i
|
item.Len = 1
|
playerStreamList.append(item)
|
streamData.AllPlayerStream = (tagMapServerPlayerSaveStream * streamData.Count)(*playerStreamList)
|
saveStream.StreamData = streamData
|
crashData.SaveStream = saveStream
|
print 'crashData.outputString() = %s'%crashData.outputString()
|
print 'crashData.getLength() = %s'%crashData.getLength()
|
print 'crashData.getBuffer() = %s'%binascii.b2a_hex(crashData.getBuffer())
|
|
crashData1 = tagMDSaveMapServerCrashData()
|
buf = crashData.getBuffer()
|
pos = 0
|
length = len(buf)
|
crashData1.readData(buf, pos, length)
|
print 'crashData1.outputString() = %s'%crashData1.outputString()
|
print 'crashData1.getLength() = %s'%crashData1.getLength()
|
print 'crashData1.getBuffer() = %s'%binascii.b2a_hex(crashData1.getBuffer())
|
|
def test_tagMapServerAllPlayerSaveStream():
|
saveStream = tagMapServerAllPlayerSaveStream()
|
print 'saveStream.outputString() = %s'%saveStream.outputString()
|
print 'saveStream.getLength() = %s'%saveStream.getLength()
|
print 'saveStream.getBuffer() = %s'%binascii.b2a_hex(saveStream.getBuffer())
|
|
saveStream.Mark = 0xFF88
|
saveStream.CRC = 123
|
saveStream.CRCCheckErrorServerType = 4
|
|
streamData = tagAllMapServerPlayerStreamData()
|
streamData.Count = 2
|
playerStreamList = []
|
for i in xrange(streamData.Count):
|
item = tagMapServerPlayerSaveStream()
|
item.Data = '%s'%i
|
item.Len = 1
|
playerStreamList.append(item)
|
streamData.AllPlayerStream = (tagMapServerPlayerSaveStream * streamData.Count)(*playerStreamList)
|
|
saveStream.StreamData = streamData
|
print 'saveStream.outputString() = %s'%saveStream.outputString()
|
print 'saveStream.getLength() = %s'%saveStream.getLength()
|
print 'saveStream.getBuffer() = %s'%binascii.b2a_hex(saveStream.getBuffer())
|
|
saveStream1 = tagMapServerAllPlayerSaveStream()
|
buf = saveStream.getBuffer()
|
pos = 0
|
length = len(buf)
|
saveStream1.readData(buf, pos, length)
|
print 'saveStream1.outputString() = %s'%saveStream1.outputString()
|
print 'saveStream1.getLength() = %s'%saveStream1.getLength()
|
print 'saveStream1.getBuffer() = %s'%binascii.b2a_hex(saveStream1.getBuffer())
|
|
def test_tagAllMapServerPlayerStreamData():
|
# print len([1,2,3])
|
streamData = tagAllMapServerPlayerStreamData()
|
print 'streamData.outputString() = %s'%streamData.outputString()
|
print 'streamData.getLength() = %s'%streamData.getLength()
|
print 'streamData.getBuffer() = %s'%binascii.b2a_hex(streamData.getBuffer())
|
|
streamData.Count = 2
|
playerStreamList = []
|
# streamData.AllPlayerStream = tagMapServerPlayerSaveStream * streamData.Count
|
for i in xrange(streamData.Count):
|
item = tagMapServerPlayerSaveStream()
|
item.Data = '%s'%i
|
item.Len = 1
|
playerStreamList.append(item)
|
streamData.AllPlayerStream = (tagMapServerPlayerSaveStream * streamData.Count)(*playerStreamList)
|
print 'streamData.outputString() = %s'%streamData.outputString()
|
print 'streamData.getLength() = %s'%streamData.getLength()
|
print 'streamData.getBuffer() = %s'%binascii.b2a_hex(streamData.getBuffer())
|
|
streamData1 = tagAllMapServerPlayerStreamData()
|
buf = streamData.getBuffer()
|
pos = 0
|
len = streamData.getLength()
|
streamData1.readData(buf, pos, len)
|
print 'streamData1.outputString() = %s'%streamData1.outputString()
|
print 'streamData1.getLength() = %s'%streamData1.getLength()
|
print 'streamData1.getBuffer() = %s'%binascii.b2a_hex(streamData1.getBuffer())
|
|
def test_tagMapServerPlayerSaveStream():
|
saveStream = tagMapServerPlayerSaveStream()
|
print 'saveStream.outputString() = %s'%saveStream.outputString()
|
print 'saveStream.getLength() = %s'%saveStream.getLength()
|
print 'saveStream.getBuffer() = %s'%binascii.b2a_hex(saveStream.getBuffer())
|
|
saveStream.Data = 'abc'
|
saveStream.Len = len(saveStream.Data)
|
print 'saveStream.outputString() = %s'%saveStream.outputString()
|
print 'saveStream.getLength() = %s'%saveStream.getLength()
|
print 'saveStream.getBuffer() = %s'%binascii.b2a_hex(saveStream.getBuffer())
|
|
saveStream1 = tagMapServerPlayerSaveStream()
|
print 'saveStream1.outputString() = %s'%saveStream1.outputString()
|
print 'saveStream1.getLength() = %s'%saveStream1.getLength()
|
print 'saveStream1.getBuffer() = %s'%binascii.b2a_hex(saveStream1.getBuffer())
|
|
buf = saveStream.getBuffer()
|
pos = 0
|
saveStream1.readData(buf, pos, len(buf))
|
print 'saveStream1.outputString() = %s'%saveStream1.outputString()
|
print 'saveStream1.getLength() = %s'%saveStream1.getLength()
|
print 'saveStream1.getBuffer() = %s'%binascii.b2a_hex(saveStream1.getBuffer())
|
|
def test_tagGDServerState():
|
serverState1 = tagGDServerState()
|
print 'serverState1.outputString() = %s'%serverState1.outputString()
|
print 'serverState1.getLength() = %s'%serverState1.getLength()
|
print 'serverState1.getBuffer() = %s'%binascii.b2a_hex(serverState1.getBuffer())
|
|
serverState1.Type = 1
|
serverState1.MapCnt = 2
|
mapServerStateList = []
|
for i in xrange(serverState1.MapCnt):
|
mapServerState = tagGDMapServerState()
|
mapServerState.MapID = 3 + i
|
mapServerState.State = 4 + i
|
mapServerState.RefreshTime = 5.0 + i
|
mapServerState.MapServerNumber = 6 + i
|
mapServerState.IP = '192.168.2.%s'%(168 + i)
|
mapServerStateList.append(mapServerState)
|
serverState1.MapServer = (tagGDMapServerState * serverState1.MapCnt)(*mapServerStateList)
|
print 'serverState1.outputString() = %s'%serverState1.outputString()
|
print 'serverState1.getLength() = %s'%serverState1.getLength()
|
print 'serverState1.getBuffer() = %s'%binascii.b2a_hex(serverState1.getBuffer())
|
|
serverState2 = tagGDServerState()
|
pos = 0
|
serverState2.readData(serverState1.getBuffer(), pos, serverState1.getLength())
|
print 'serverState2.outputString() = %s'%serverState2.outputString()
|
print 'serverState2.getLength() = %s'%serverState2.getLength()
|
print 'serverState2.getBuffer() = %s'%binascii.b2a_hex(serverState2.getBuffer())
|
|
def test():
|
mylog.InitMyLog('test_RecvProtocol.log')
|
|
xGSGetGameData = tagGSGetGameData()
|
mylog.info('init %s'%xGSGetGameData.outputString())
|
|
mylog.info('xGSGetGameData.getLength() = %s'%xGSGetGameData.getLength())
|
|
xGSGetGameData.Type = 1
|
xGSGetGameData.MapID = 101
|
mylog.info('buf = %s'%(binascii.b2a_hex(xGSGetGameData.getBuffer())))
|
|
xGSGetGameData1 = tagGSGetGameData()
|
mylog.info('xGSGetGameData1 init %s'%xGSGetGameData1.outputString())
|
|
pos = 0
|
readLen = xGSGetGameData1.readData(xGSGetGameData.getBuffer(), pos, xGSGetGameData.getLength())
|
if readLen <= 0:
|
mylog.error('error in readData')
|
return
|
mylog.info('readLen = %s'%readLen)
|
mylog.info('after readData %s'%xGSGetGameData1.outputString())
|
|
|
if __name__ == '__main__':
|
test_tagMDSaveMapServerCrashData()
|
# test_tagMapServerAllPlayerSaveStream()
|
# test_tagAllMapServerPlayerStreamData()
|
# test_tagMapServerPlayerSaveStream()
|
# test_tagGDServerState()
|
# test()
|
