#!/usr/bin/python
|
# -*- coding: gbk -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
#
|
|
#·¢ËÍ·â°üÐÒé
|
#ʹÓÃProtocolStudio.CodeMaker.ÆÕͨ.NewParseNetPackStruct.pyÉú³É
|
#Éú³ÉµÄ´úÂë²»ÄÜEclipseÖ±½Ó±£´æ£¬ÒªÍ¨¹ýUE»òÆäËû±à¼Æ÷±£´æ£¬·ñÔò»áÌáʾ±àÂëÎÊÌâ
|
|
from ctypes import (Structure, c_int, c_ubyte, c_ulong, memset, addressof, sizeof, create_string_buffer,
|
memmove, string_at, resize, POINTER)
|
from Common import (CommFunc, mylog)
|
from PackCommonDef import tagHead
|
|
#Êý¾Ý¿â³õʼ»¯OK#tagDataServerInitOK
|
|
class tagDataServerInitOK(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDataServerInitOK)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 1)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//Êý¾Ý¿â³õʼ»¯OK//tagDataServerInitOK:
|
Type:%d
|
'''\
|
%(
|
self.Type
|
)
|
return DumpString
|
|
#·µ»ØÓïÑÔ°æ±¾#tagRetServerVersion
|
|
class tagRetServerVersion(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("MapServerIndex", c_int),
|
("Version", c_int),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.MapServerIndex = 0
|
self.Version = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagRetServerVersion)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 9)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//·µ»ØÓïÑÔ°æ±¾//tagRetServerVersion:
|
Type:%d,
|
MapServerIndex:%d,
|
Version:%d
|
'''\
|
%(
|
self.Type,
|
self.MapServerIndex,
|
self.Version
|
)
|
return DumpString
|
|
#Type->Value¶¨Òå#tagDServerValueType
|
|
class tagDServerValueType(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("Value", c_int),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.Value = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDServerValueType)
|
|
def GetBuffer(self):
|
return string_at(addressof(self), self.GetLength())
|
|
def OutputString(self):
|
DumpString = '''//Type->Value¶¨Òå//tagDServerValueType:
|
Type:%d,
|
Value:%d
|
'''\
|
%(
|
self.Type,
|
self.Value
|
)
|
return DumpString
|
|
#Êý¾Ý¿â·þÎñÆ÷»Ø±¨µØͼ·þÎñÆ÷·â°üÍ·#tagDBToMapServerHead
|
|
class tagDBToMapServerHead(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("Success", c_ubyte),
|
("MapID", c_int),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.Success = 0
|
self.MapID = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDBToMapServerHead)
|
|
def GetBuffer(self):
|
return string_at(addressof(self), self.GetLength())
|
|
def OutputString(self):
|
DumpString = '''//Êý¾Ý¿â·þÎñÆ÷»Ø±¨µØͼ·þÎñÆ÷·â°üÍ·//tagDBToMapServerHead:
|
Type:%d,
|
Success:%d,
|
MapID:%d
|
'''\
|
%(
|
self.Type,
|
self.Success,
|
self.MapID
|
)
|
return DumpString
|
|
|
|
|
#Ö´ÐиüеĽá¹û#tagDBUpdateReturn
|
|
class tagDBUpdateReturn(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("CallType", c_ubyte), #=update
|
("UpdateType", c_ubyte),
|
("Result", c_ubyte),
|
("MapID", c_int),
|
("PlayerID", c_int),
|
("ADOResult", c_int), #ÔÏȵķâ°ü»ûÐΰ¡,²Á¡£¡£¡£
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.CallType = 0
|
self.UpdateType = 0
|
self.Result = 0
|
self.MapID = 0
|
self.PlayerID = 0
|
self.ADOResult = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDBUpdateReturn)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 15)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//Ö´ÐиüеĽá¹û//tagDBUpdateReturn:
|
CallType:%d,
|
UpdateType:%d,
|
Result:%d,
|
MapID:%d,
|
PlayerID:%d,
|
ADOResult:%d
|
'''\
|
%(
|
self.CallType,
|
self.UpdateType,
|
self.Result,
|
self.MapID,
|
self.PlayerID,
|
self.ADOResult
|
)
|
return DumpString
|
|
#Êý¾Ý¿â·þÎñÆ÷»Ø±¨GameServer·â°üÍ·#tagDBToGameServerHead
|
|
class tagDBToGameServerHead(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("Success", c_ubyte),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.Success = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDBToGameServerHead)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 2)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//Êý¾Ý¿â·þÎñÆ÷»Ø±¨GameServer·â°üÍ·//tagDBToGameServerHead:
|
Type:%d,
|
Success:%d
|
'''\
|
%(
|
self.Type,
|
self.Success
|
)
|
return DumpString
|
|
#·þÎñÆ÷¶Ë°æ±¾Áбí#tagServerGroupVersions
|
|
class tagServerGroupVersion(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("MajorVersion", c_int),
|
("MinorVersion", c_int),
|
("LanguageVersion", c_int),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.MajorVersion = 0
|
self.MinorVersion = 0
|
self.LanguageVersion = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagServerGroupVersion)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 12)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//·þÎñÆ÷¶Ë°æ±¾Áбí//tagServerGroupVersions:
|
MajorVersion:%d,
|
MinorVersion:%d,
|
LanguageVersion:%d
|
'''\
|
%(
|
self.MajorVersion,
|
self.MinorVersion,
|
self.LanguageVersion
|
)
|
return DumpString
|
|
|
class tagServerGroupVersions(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("VersionCnt", c_int),
|
("VersionList", POINTER(tagServerGroupVersion)),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
length = 1
|
pos = 0
|
memmove(addressof(self) + pos, stringData[_pos:], length)
|
pos += length
|
_pos += length
|
length = 4
|
memmove(addressof(self) + pos, stringData[_pos:], length)
|
pos += length
|
_pos += length
|
|
VersionList = []
|
for i in range(self.VersionCnt):
|
value = tagServerGroupVersion()
|
_pos = value.ReadData(stringData, _pos)
|
VersionList.append(value)
|
self.VersionList = (tagServerGroupVersion * self.VersionCnt)(*VersionList)
|
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.VersionCnt = 0
|
self.VersionList = None
|
return
|
|
def GetLength(self):
|
return sizeof(tagServerGroupVersions) - sizeof(POINTER(tagServerGroupVersion)) + self.VersionCnt * sizeof(tagServerGroupVersion)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 5)
|
addrOfBuf += 5
|
for i in range(self.VersionCnt):
|
length = self.VersionList[i].GetLength()
|
memmove(addrOfBuf, self.VersionList[i].GetBuffer(), length)
|
addrOfBuf += length
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
verList = []
|
for i in xrange(self.VersionCnt):
|
verList.append(self.VersionList[i].OutputString())
|
versionList = ';'.join(verList)
|
DumpString = '''//·þÎñÆ÷¶Ë°æ±¾Áбí//tagServerGroupVersions:
|
Type:%d,
|
VersionCnt:%d,
|
VersionList:%s
|
'''\
|
%(
|
self.Type,
|
self.VersionCnt,
|
versionList
|
)
|
return DumpString
|
|
|
#GMÃüÁîÖ´Ðнá¹û#tagGMCommandResult
|
|
class tagGMCommandResult(Structure):
|
Type = 0 #(BYTE Type)
|
ResultLen = 0 #(DWORD ResultLen)
|
Result = "" #(String Result)
|
UserDataLen = 0 #(DWORD UserDataLen)
|
UserData = "" #(String UserData)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ResultLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultLen)
|
self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.ResultLen = 0
|
self.Result = ""
|
self.UserDataLen = 0
|
self.UserData = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += len(self.Result)
|
length += 4
|
length += len(self.UserData)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.ResultLen)
|
data = CommFunc.WriteString(data, self.ResultLen, self.Result)
|
data = CommFunc.WriteDWORD(data, self.UserDataLen)
|
data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
ResultLen:%d,
|
Result:%s,
|
UserDataLen:%d,
|
UserData:%s
|
'''\
|
%(
|
self.Type,
|
self.ResultLen,
|
self.Result,
|
self.UserDataLen,
|
self.UserData
|
)
|
return DumpString
|
|
|
#-----------------------
|
#01 22 ºÏ·þÍæ¼ÒÐÅÏ¢#tagServerMergeInfo
|
|
class tagServerMergePlayer(Structure):
|
PlayerID = 0 #(DWORD PlayerID)
|
Name = "" #(char Name[33])
|
LeaderFamilyID = 0 #(DWORD LeaderFamilyID)//Èç¹ûÊǼÒ×峤µÄ»°, ¼Ò×åIDÌîд, ²»ÊǼÒ×峤¾Í²»Ìî
|
Job = 0 #(BYTE Job)
|
Sex = 0 #(BYTE Sex)
|
LV = 0 #(WORD LV)
|
TotalSTR = 0 #(DWORD TotalSTR)//Á¦Á¿
|
TotalPNE = 0 #(DWORD TotalPNE)//ÕæÔª
|
TotalPHY = 0 #(DWORD TotalPHY)//½î¹Ç
|
TotalCON = 0 #(DWORD TotalCON)//ÌåÆÇ
|
Gold = 0 #(DWORD Gold)
|
GoldPaper = 0 #(DWORD GoldPaper)
|
Silver = 0 #(DWORD Silver)
|
SilverPaper = 0 #(DWORD SilverPaper)
|
WarehouseGold = 0 #(DWORD WarehouseGold)
|
WarehouseSilver = 0 #(DWORD WarehouseSilver)
|
FightPower = 0 #(DWORD FightPower)//Õ½¶·Á¦
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
|
self.LeaderFamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Sex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.TotalSTR,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.TotalPNE,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.TotalPHY,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.TotalCON,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Gold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.GoldPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Silver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.SilverPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.WarehouseGold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.WarehouseSilver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.PlayerID = 0
|
self.Name = ""
|
self.LeaderFamilyID = 0
|
self.Job = 0
|
self.Sex = 0
|
self.LV = 0
|
self.TotalSTR = 0
|
self.TotalPNE = 0
|
self.TotalPHY = 0
|
self.TotalCON = 0
|
self.Gold = 0
|
self.GoldPaper = 0
|
self.Silver = 0
|
self.SilverPaper = 0
|
self.WarehouseGold = 0
|
self.WarehouseSilver = 0
|
self.FightPower = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 4
|
length += 33
|
length += 4
|
length += 1
|
length += 1
|
length += 2
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteDWORD(data, self.PlayerID)
|
data = CommFunc.WriteString(data, 33, self.Name)
|
data = CommFunc.WriteDWORD(data, self.LeaderFamilyID)
|
data = CommFunc.WriteBYTE(data, self.Job)
|
data = CommFunc.WriteBYTE(data, self.Sex)
|
data = CommFunc.WriteWORD(data, self.LV)
|
data = CommFunc.WriteDWORD(data, self.TotalSTR)
|
data = CommFunc.WriteDWORD(data, self.TotalPNE)
|
data = CommFunc.WriteDWORD(data, self.TotalPHY)
|
data = CommFunc.WriteDWORD(data, self.TotalCON)
|
data = CommFunc.WriteDWORD(data, self.Gold)
|
data = CommFunc.WriteDWORD(data, self.GoldPaper)
|
data = CommFunc.WriteDWORD(data, self.Silver)
|
data = CommFunc.WriteDWORD(data, self.SilverPaper)
|
data = CommFunc.WriteDWORD(data, self.WarehouseGold)
|
data = CommFunc.WriteDWORD(data, self.WarehouseSilver)
|
data = CommFunc.WriteDWORD(data, self.FightPower)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
PlayerID:%d,
|
Name:%s,
|
LeaderFamilyID:%d,
|
Job:%d,
|
Sex:%d,
|
LV:%d,
|
TotalSTR:%d,
|
TotalPNE:%d,
|
TotalPHY:%d,
|
TotalCON:%d,
|
Gold:%d,
|
GoldPaper:%d,
|
Silver:%d,
|
SilverPaper:%d,
|
WarehouseGold:%d,
|
WarehouseSilver:%d,
|
FightPower:%d
|
'''\
|
%(
|
self.PlayerID,
|
self.Name,
|
self.LeaderFamilyID,
|
self.Job,
|
self.Sex,
|
self.LV,
|
self.TotalSTR,
|
self.TotalPNE,
|
self.TotalPHY,
|
self.TotalCON,
|
self.Gold,
|
self.GoldPaper,
|
self.Silver,
|
self.SilverPaper,
|
self.WarehouseGold,
|
self.WarehouseSilver,
|
self.FightPower
|
)
|
return DumpString
|
|
|
class tagServerMergeInfo(Structure):
|
Head = tagHead()
|
PlayerCount = 0 #(WORD PlayerCount)
|
Players = list() #(vector<tagServerMergePlayer> Players)//size = PlayerCount
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x22
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
_pos = self.Head.ReadData(_lpData, _pos)
|
self.PlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
for i in range(self.PlayerCount):
|
temPlayers = tagServerMergePlayer()
|
_pos = temPlayers.ReadData(_lpData, _pos)
|
self.Players.append(temPlayers)
|
return _pos
|
|
def Clear(self):
|
self.Head = tagHead()
|
self.Head.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x22
|
self.PlayerCount = 0
|
self.Players = list()
|
return
|
|
def GetLength(self):
|
length = 0
|
length += self.Head.GetLength()
|
length += 2
|
for i in range(self.PlayerCount):
|
length += self.Players[i].GetLength()
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
|
data = CommFunc.WriteWORD(data, self.PlayerCount)
|
for i in range(self.PlayerCount):
|
data = CommFunc.WriteString(data, self.Players[i].GetLength(), self.Players[i].GetBuffer())
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Head:%s,
|
PlayerCount:%d,
|
Players:%s
|
'''\
|
%(
|
self.Head.OutputString(),
|
self.PlayerCount,
|
"..."
|
)
|
return DumpString
|
|
#¼ì²éÍæ¼ÒÃû³ÆÊÇ·ñ´æÔÚtagDBPlayerNameIsExist
|
|
class tagDBPlayerNameIsExist(Structure):
|
CallType = 0 #(BYTE CallType)
|
Result = 0 #(BYTE Result)
|
NameLen = 0 #(BYTE NameLen)
|
Name = "" #(String Name)//size = NameLen
|
PlayerID = 0 #(DWORD PlayerID)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.CallType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
|
self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.CallType = 0
|
self.Result = 0
|
self.NameLen = 0
|
self.Name = ""
|
self.PlayerID = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.Name)
|
length += 4
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.CallType)
|
data = CommFunc.WriteBYTE(data, self.Result)
|
data = CommFunc.WriteBYTE(data, self.NameLen)
|
data = CommFunc.WriteString(data, self.NameLen, self.Name)
|
data = CommFunc.WriteDWORD(data, self.PlayerID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
CallType:%d,
|
Result:%d,
|
NameLen:%d,
|
Name:%s,
|
PlayerID:%d
|
'''\
|
%(
|
self.CallType,
|
self.Result,
|
self.NameLen,
|
self.Name,
|
self.PlayerID
|
)
|
return DumpString
|
|
|
class tagPlayerMailInfo(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Cmd", c_ubyte),
|
("SubCmd", c_ubyte),
|
("InfoType", c_ubyte), #TPlayerMailInfo
|
]
|
|
def __init__(self):
|
self.Clear()
|
self.Cmd = 0x12
|
self.SubCmd = 0x07
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Cmd = 0x12
|
self.SubCmd = 0x07
|
self.InfoType = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagPlayerMailInfo)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 3)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//12 07tagPlayerMailInfo:
|
Cmd:%s,
|
SubCmd:%s,
|
InfoType:%d
|
'''\
|
%(
|
self.Cmd,
|
self.SubCmd,
|
self.InfoType
|
)
|
return DumpString
|
|
|
#ÓʼþÏêÇéÍæ¼Ò²é¿´tagDBMailDetailView
|
|
class tagDBMailDetailView(Structure):
|
Type = 0 #(BYTE Type)
|
MailDetailDataLen = 0 #(DWORD MailDetailDataLen)
|
MailDetailData = "" #(String MailDetailData)//size = MailDetailDataLen
|
MailItemDataLen = 0 #(DWORD MailItemDataLen)
|
MailItemData = "" #(String MailItemData)//size = MailItemDataLen
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.MailDetailDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MailDetailData,_pos = CommFunc.ReadString(_lpData, _pos,self.MailDetailDataLen)
|
self.MailItemDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MailItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.MailItemDataLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.MailDetailDataLen = 0
|
self.MailDetailData = ""
|
self.MailItemDataLen = 0
|
self.MailItemData = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += len(self.MailDetailData)
|
length += 4
|
length += len(self.MailItemData)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.MailDetailDataLen)
|
data = CommFunc.WriteString(data, self.MailDetailDataLen, self.MailDetailData)
|
data = CommFunc.WriteDWORD(data, self.MailItemDataLen)
|
data = CommFunc.WriteString(data, self.MailItemDataLen, self.MailItemData)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
MailDetailDataLen:%d,
|
MailDetailData:%s,
|
MailItemDataLen:%d,
|
MailItemData:%s
|
'''\
|
%(
|
self.Type,
|
self.MailDetailDataLen,
|
self.MailDetailData,
|
self.MailItemDataLen,
|
self.MailItemData
|
)
|
return DumpString
|
|
#ÓʼþÁбíÍæ¼Ò²é¿´#tagDBGetPlayerMail
|
|
class tagDBMailInfo(Structure):
|
MailID = "" #(char MailID[40])//ÐżþµÄID
|
MailType = 0 #(BYTE MailType)//0. δ¶Á 1.Òѱ£´æ......
|
LetterType = 0 #(BYTE LetterType)//¶Ô·½¸¶·Ñ, ×Ô¼º¸¶·Ñ
|
SenderName = "" #(char SenderName[33])//¼ÄÐÅÈËÃû×Ö
|
Title = "" #(char Title[21])//Ö÷Ìâ
|
TitleUseSystemMessage = 0 #(BYTE TitleUseSystemMessage)//±êÌâÊÇ·ñʹÓÃSystemMessage
|
ExistTime = 0 #(BYTE ExistTime)//Ðżþ´æÔÚʱ¼ä(Ìì)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.MailID,_pos = CommFunc.ReadString(_lpData, _pos,40)
|
self.MailType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.LetterType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SenderName,_pos = CommFunc.ReadString(_lpData, _pos,33)
|
self.Title,_pos = CommFunc.ReadString(_lpData, _pos,21)
|
self.TitleUseSystemMessage,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ExistTime,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.MailID = ""
|
self.MailType = 0
|
self.LetterType = 0
|
self.SenderName = ""
|
self.Title = ""
|
self.TitleUseSystemMessage = 0
|
self.ExistTime = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 40
|
length += 1
|
length += 1
|
length += 33
|
length += 21
|
length += 1
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteString(data, 40, self.MailID)
|
data = CommFunc.WriteBYTE(data, self.MailType)
|
data = CommFunc.WriteBYTE(data, self.LetterType)
|
data = CommFunc.WriteString(data, 33, self.SenderName)
|
data = CommFunc.WriteString(data, 21, self.Title)
|
data = CommFunc.WriteBYTE(data, self.TitleUseSystemMessage)
|
data = CommFunc.WriteBYTE(data, self.ExistTime)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
MailID:%s,
|
MailType:%d,
|
LetterType:%d,
|
SenderName:%s,
|
Title:%s,
|
TitleUseSystemMessage:%d,
|
ExistTime:%d
|
'''\
|
%(
|
self.MailID,
|
self.MailType,
|
self.LetterType,
|
self.SenderName,
|
self.Title,
|
self.TitleUseSystemMessage,
|
self.ExistTime
|
)
|
return DumpString
|
|
|
class tagDBGetPlayerMail(Structure):
|
Type = 0 #(BYTE Type)
|
MailCount = 0 #(WORD MailCount)
|
Mail = list() #(vector<tagDBMailInfo> Mail)//size = MailCount
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.MailCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
for i in range(self.MailCount):
|
temMail = tagDBMailInfo()
|
_pos = temMail.ReadData(_lpData, _pos)
|
self.Mail.append(temMail)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.MailCount = 0
|
self.Mail = list()
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 2
|
for i in range(self.MailCount):
|
length += self.Mail[i].GetLength()
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteWORD(data, self.MailCount)
|
for i in range(self.MailCount):
|
data = CommFunc.WriteString(data, self.Mail[i].GetLength(), self.Mail[i].GetBuffer())
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
MailCount:%d,
|
Mail:%s
|
'''\
|
%(
|
self.Type,
|
self.MailCount,
|
"..."
|
)
|
return DumpString
|
|
#Íæ¼ÒµÃµ½ÎïÆ·#tagDPlayerGetItem
|
class tagDPlayerGetItem(Structure):
|
_pack_ = 1
|
_fields_ = [
|
("Type", c_ubyte),
|
("ItemID", c_int),
|
("Count", c_int),
|
("RemainItemCount", c_int), #Ê£ÓàÁìÈ¡ÎïÆ·ÊýÄ¿
|
("IsBind", c_ubyte),
|
]
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, stringData, _pos=0, _len=0):
|
self.Clear()
|
memmove(addressof(self), stringData[_pos:], self.GetLength())
|
return _pos + self.GetLength()
|
|
def Clear(self):
|
self.Type = 0
|
self.ItemID = 0
|
self.Count = 0
|
self.RemainItemCount = 0
|
self.IsBind = 0
|
return
|
|
def GetLength(self):
|
return sizeof(tagDPlayerGetItem)
|
|
def GetBuffer(self):
|
selfLength = self.GetLength()
|
buf = create_string_buffer(selfLength)
|
addrOfBuf = addressof(buf)
|
memmove(addrOfBuf, addressof(self), 14)
|
return string_at(addressof(buf), selfLength)
|
|
def OutputString(self):
|
DumpString = '''//Íæ¼ÒµÃµ½ÎïÆ·//tagDPlayerGetItem:
|
Type:%d,
|
ItemID:%d,
|
Count:%d,
|
RemainItemCount:%d,
|
IsBind:%d
|
'''\
|
%(
|
self.Type,
|
self.ItemID,
|
self.Count,
|
self.RemainItemCount,
|
self.IsBind
|
)
|
return DumpString
|
|
|
#01 09 Ìí¼ÓÎïÆ·³É¹¦#tagIAddItemResult
|
|
class tagIAddItemResult(Structure):
|
Head = tagHead()
|
AccLen = 0 #(BYTE AccLen)
|
Acc = "" #(String Acc)//size = AccLen
|
ItemID = 0 #(DWORD ItemID)
|
Count = 0 #(WORD Count)
|
Result = 0 #(BYTE Result)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x09
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
_pos = self.Head.ReadData(_lpData, _pos)
|
self.AccLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Acc,_pos = CommFunc.ReadString(_lpData, _pos,self.AccLen)
|
self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Head = tagHead()
|
self.Head.Clear()
|
self.Head.Cmd = 0x01
|
self.Head.SubCmd = 0x09
|
self.AccLen = 0
|
self.Acc = ""
|
self.ItemID = 0
|
self.Count = 0
|
self.Result = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += self.Head.GetLength()
|
length += 1
|
length += len(self.Acc)
|
length += 4
|
length += 2
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
|
data = CommFunc.WriteBYTE(data, self.AccLen)
|
data = CommFunc.WriteString(data, self.AccLen, self.Acc)
|
data = CommFunc.WriteDWORD(data, self.ItemID)
|
data = CommFunc.WriteWORD(data, self.Count)
|
data = CommFunc.WriteBYTE(data, self.Result)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Head:%s,
|
AccLen:%d,
|
Acc:%s,
|
ItemID:%d,
|
Count:%d,
|
Result:%d
|
'''\
|
%(
|
self.Head.OutputString(),
|
self.AccLen,
|
self.Acc,
|
self.ItemID,
|
self.Count,
|
self.Result
|
)
|
return DumpString
|
|
#½ðÇ®²¹³¥±í#tagExpiation
|
|
class tagExpiation(Structure):
|
ExpiationIndex = 0 #(DWORD ExpiationIndex)//_IDT_KEY_
|
AccID = "" #(char AccID[65])//_I_
|
ExpiationTime = 0 #(double ExpiationTime)//²¹³¥Ê±¼ä, ×ö¼Ç¼ÓÃ
|
Gold = 0 #(DWORD Gold)//½ð×Ó
|
GoldPaper = 0 #(DWORD GoldPaper)//½ðƱ
|
Silver = 0 #(DWORD Silver)//Òø×Ó
|
SilverPaper = 0 #(DWORD SilverPaper)//񿮱
|
ItemTypeID = 0 #(DWORD ItemTypeID)//ÎïÆ·ID
|
Count = 0 #(WORD Count)//µ¥×éÊýÁ¿
|
IsLocked = 0 #(BYTE IsLocked)//ÊÇ·ñËø¶¨
|
ItemPlaceType = 0 #(BYTE ItemPlaceType)//ÎïƷλÖõÄÀàÐÍ
|
ItemPlaceIndex = 0 #(WORD ItemPlaceIndex)//ÎïÆ·ËùÔÚµÄË÷Òý
|
IsBind = 0 #(BYTE IsBind)//ÊÇ·ñ°ó¶¨
|
ItemStarLV = 0 #(BYTE ItemStarLV)//×°±¸ÐǼ¶
|
IdentifyPar = 0 #(BYTE IdentifyPar)//¼ø¶¨²ÎÊý
|
CurDurg = 0 #(DWORD CurDurg)//µ±Ç°Ä;Ã
|
MaxDurg = 0 #(DWORD MaxDurg)//×î´óÄ;Ã
|
CanPlaceStoneCount = 0 #(BYTE CanPlaceStoneCount)//¿ÉÏâǶ±¦Ê¯Êý0±íʾ²»¿ÉÒÔÏâǶ±¦Ê¯
|
ItemProperty = 0 #(BYTE ItemProperty)//×°±¸ÎåÐÐ
|
SoulProperty = 0 #(WORD SoulProperty)//Áé»êÊôÐÔÊôÐÔ
|
Maker = 0 #(DWORD Maker)//ÖÆ×÷ÕßID
|
MakerName = "" #(char MakerName[33])//ÖÆÔìÕßÃû×Ö
|
Stone1 = 0 #(DWORD Stone1)//ÏâǶ±¦Ê¯1
|
Stone2 = 0 #(DWORD Stone2)//ÏâǶ±¦Ê¯
|
Stone3 = 0 #(DWORD Stone3)//ÏâǶ±¦Ê¯
|
Stone4 = 0 #(DWORD Stone4)//ÏâǶ±¦Ê¯
|
Stone5 = 0 #(DWORD Stone5)//ÏâǶ±¦Ê¯
|
Stone6 = 0 #(DWORD Stone6)//ÏâǶ±¦Ê¯
|
Stone7 = 0 #(DWORD Stone7)//ÏâǶ±¦Ê¯
|
Stone8 = 0 #(DWORD Stone8)//ÏâǶ±¦Ê¯
|
Stone9 = 0 #(DWORD Stone9)//ÏâǶ±¦Ê¯
|
RemainHour = 0 #(WORD RemainHour)//Ê£Óàʱ¼ä(Сʱ)
|
CreateTime = "" #(char CreateTime[30])//´´½¨Ê±¼ä
|
ElementEffect = 0 #(BYTE ElementEffect)//¿ª¹â״̬
|
IsSuite = 0 #(BYTE IsSuite)//ÊÇ·ñÒѾÌ××°»¯
|
FitLV = 0 #(BYTE FitLV)//ÎïÆ·ÆõºÏµÈ¼¶
|
EquipAddSkillCnt = 0 #(BYTE EquipAddSkillCnt)//ÁéÎÆ´ÎÊý
|
ExpireTime = 0 #(WORD ExpireTime)//ÎïÆ·ÓÐЧʱ¼ä(Сʱ)
|
BaseAtkPlus = 0 #(DWORD BaseAtkPlus)//»ù´¡¹¥»÷¼Ó³É
|
BaseDefPlus = 0 #(DWORD BaseDefPlus)//»ù´¡·ÀÓù¼Ó³É
|
AddSkillData = "" #(char AddSkillData[300])///ÁéÎƼ¼ÄÜÁбí×Ö·û´®
|
BaseHP = 0 #(DWORD BaseHP)// HP»ù´¡Öµ
|
BaseMagicDef = 0 #(DWORD BaseMagicDef)//ÄÚ·À»ù´¡Öµ
|
EquipMinAtkValue = 0 #(DWORD EquipMinAtkValue)//×°±¸µÄ×îСÉ˺¦Öµ
|
Proficiency = 0 #(DWORD Proficiency)//ÊìÁ·¶È
|
RelMaxAddSkillCnt = 0 #(BYTE RelMaxAddSkillCnt)// ×î´ó¸½Ä§´ÎÊý
|
FamilyActiveValue = 0 #(DWORD FamilyActiveValue)//¼Ò×å»îÔ¾¶È
|
UserDataLen = 0 #(DWORD UserDataLen)//×Ô¶¨ÒåÊý¾Ý³¤¶È
|
UserData = "" #(String UserData)//×Ô¶¨ÒåÊý¾Ý
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.ExpiationIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.ExpiationTime,_pos = CommFunc.ReadDouble(_lpData, _pos)
|
self.Gold,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.GoldPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Silver,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.SilverPaper,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ItemTypeID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.IsLocked,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ItemPlaceType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ItemPlaceIndex,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.IsBind,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ItemStarLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.IdentifyPar,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.CurDurg,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MaxDurg,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.CanPlaceStoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ItemProperty,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SoulProperty,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.Maker,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.MakerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
|
self.Stone1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Stone9,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.RemainHour,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.CreateTime,_pos = CommFunc.ReadString(_lpData, _pos,30)
|
self.ElementEffect,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.IsSuite,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.FitLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.EquipAddSkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ExpireTime,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.BaseAtkPlus,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.BaseDefPlus,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.AddSkillData,_pos = CommFunc.ReadString(_lpData, _pos,300)
|
self.BaseHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.BaseMagicDef,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.EquipMinAtkValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Proficiency,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.RelMaxAddSkillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.FamilyActiveValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
|
return _pos
|
|
def Clear(self):
|
self.ExpiationIndex = 0
|
self.AccID = ""
|
self.ExpiationTime = 0
|
self.Gold = 0
|
self.GoldPaper = 0
|
self.Silver = 0
|
self.SilverPaper = 0
|
self.ItemTypeID = 0
|
self.Count = 0
|
self.IsLocked = 0
|
self.ItemPlaceType = 0
|
self.ItemPlaceIndex = 0
|
self.IsBind = 0
|
self.ItemStarLV = 0
|
self.IdentifyPar = 0
|
self.CurDurg = 0
|
self.MaxDurg = 0
|
self.CanPlaceStoneCount = 0
|
self.ItemProperty = 0
|
self.SoulProperty = 0
|
self.Maker = 0
|
self.MakerName = ""
|
self.Stone1 = 0
|
self.Stone2 = 0
|
self.Stone3 = 0
|
self.Stone4 = 0
|
self.Stone5 = 0
|
self.Stone6 = 0
|
self.Stone7 = 0
|
self.Stone8 = 0
|
self.Stone9 = 0
|
self.RemainHour = 0
|
self.CreateTime = ""
|
self.ElementEffect = 0
|
self.IsSuite = 0
|
self.FitLV = 0
|
self.EquipAddSkillCnt = 0
|
self.ExpireTime = 0
|
self.BaseAtkPlus = 0
|
self.BaseDefPlus = 0
|
self.AddSkillData = ""
|
self.BaseHP = 0
|
self.BaseMagicDef = 0
|
self.EquipMinAtkValue = 0
|
self.Proficiency = 0
|
self.RelMaxAddSkillCnt = 0
|
self.FamilyActiveValue = 0
|
self.UserDataLen = 0
|
self.UserData = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 4
|
length += 65
|
length += 8
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 2
|
length += 1
|
length += 1
|
length += 2
|
length += 1
|
length += 1
|
length += 1
|
length += 4
|
length += 4
|
length += 1
|
length += 1
|
length += 2
|
length += 4
|
length += 33
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 2
|
length += 30
|
length += 1
|
length += 1
|
length += 1
|
length += 1
|
length += 2
|
length += 4
|
length += 4
|
length += 300
|
length += 4
|
length += 4
|
length += 4
|
length += 4
|
length += 1
|
length += 4
|
length += 4
|
length += len(self.UserData)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteDWORD(data, self.ExpiationIndex)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteDouble(data, self.ExpiationTime)
|
data = CommFunc.WriteDWORD(data, self.Gold)
|
data = CommFunc.WriteDWORD(data, self.GoldPaper)
|
data = CommFunc.WriteDWORD(data, self.Silver)
|
data = CommFunc.WriteDWORD(data, self.SilverPaper)
|
data = CommFunc.WriteDWORD(data, self.ItemTypeID)
|
data = CommFunc.WriteWORD(data, self.Count)
|
data = CommFunc.WriteBYTE(data, self.IsLocked)
|
data = CommFunc.WriteBYTE(data, self.ItemPlaceType)
|
data = CommFunc.WriteWORD(data, self.ItemPlaceIndex)
|
data = CommFunc.WriteBYTE(data, self.IsBind)
|
data = CommFunc.WriteBYTE(data, self.ItemStarLV)
|
data = CommFunc.WriteBYTE(data, self.IdentifyPar)
|
data = CommFunc.WriteDWORD(data, self.CurDurg)
|
data = CommFunc.WriteDWORD(data, self.MaxDurg)
|
data = CommFunc.WriteBYTE(data, self.CanPlaceStoneCount)
|
data = CommFunc.WriteBYTE(data, self.ItemProperty)
|
data = CommFunc.WriteWORD(data, self.SoulProperty)
|
data = CommFunc.WriteDWORD(data, self.Maker)
|
data = CommFunc.WriteString(data, 33, self.MakerName)
|
data = CommFunc.WriteDWORD(data, self.Stone1)
|
data = CommFunc.WriteDWORD(data, self.Stone2)
|
data = CommFunc.WriteDWORD(data, self.Stone3)
|
data = CommFunc.WriteDWORD(data, self.Stone4)
|
data = CommFunc.WriteDWORD(data, self.Stone5)
|
data = CommFunc.WriteDWORD(data, self.Stone6)
|
data = CommFunc.WriteDWORD(data, self.Stone7)
|
data = CommFunc.WriteDWORD(data, self.Stone8)
|
data = CommFunc.WriteDWORD(data, self.Stone9)
|
data = CommFunc.WriteWORD(data, self.RemainHour)
|
data = CommFunc.WriteString(data, 30, self.CreateTime)
|
data = CommFunc.WriteBYTE(data, self.ElementEffect)
|
data = CommFunc.WriteBYTE(data, self.IsSuite)
|
data = CommFunc.WriteBYTE(data, self.FitLV)
|
data = CommFunc.WriteBYTE(data, self.EquipAddSkillCnt)
|
data = CommFunc.WriteWORD(data, self.ExpireTime)
|
data = CommFunc.WriteDWORD(data, self.BaseAtkPlus)
|
data = CommFunc.WriteDWORD(data, self.BaseDefPlus)
|
data = CommFunc.WriteString(data, 300, self.AddSkillData)
|
data = CommFunc.WriteDWORD(data, self.BaseHP)
|
data = CommFunc.WriteDWORD(data, self.BaseMagicDef)
|
data = CommFunc.WriteDWORD(data, self.EquipMinAtkValue)
|
data = CommFunc.WriteDWORD(data, self.Proficiency)
|
data = CommFunc.WriteBYTE(data, self.RelMaxAddSkillCnt)
|
data = CommFunc.WriteDWORD(data, self.FamilyActiveValue)
|
data = CommFunc.WriteDWORD(data, self.UserDataLen)
|
data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
ExpiationIndex:%d,
|
AccID:%s,
|
ExpiationTime:%s,
|
Gold:%d,
|
GoldPaper:%d,
|
Silver:%d,
|
SilverPaper:%d,
|
ItemTypeID:%d,
|
Count:%d,
|
IsLocked:%d,
|
ItemPlaceType:%d,
|
ItemPlaceIndex:%d,
|
IsBind:%d,
|
ItemStarLV:%d,
|
IdentifyPar:%d,
|
CurDurg:%d,
|
MaxDurg:%d,
|
CanPlaceStoneCount:%d,
|
ItemProperty:%d,
|
SoulProperty:%d,
|
Maker:%d,
|
MakerName:%s,
|
Stone1:%d,
|
Stone2:%d,
|
Stone3:%d,
|
Stone4:%d,
|
Stone5:%d,
|
Stone6:%d,
|
Stone7:%d,
|
Stone8:%d,
|
Stone9:%d,
|
RemainHour:%d,
|
CreateTime:%s,
|
ElementEffect:%d,
|
IsSuite:%d,
|
FitLV:%d,
|
EquipAddSkillCnt:%d,
|
ExpireTime:%d,
|
BaseAtkPlus:%d,
|
BaseDefPlus:%d,
|
AddSkillData:%s,
|
BaseHP:%d,
|
BaseMagicDef:%d,
|
EquipMinAtkValue:%d,
|
Proficiency:%d,
|
RelMaxAddSkillCnt:%d,
|
FamilyActiveValue:%d,
|
UserDataLen:%d,
|
UserData:%s
|
'''\
|
%(
|
self.ExpiationIndex,
|
self.AccID,
|
self.ExpiationTime,
|
self.Gold,
|
self.GoldPaper,
|
self.Silver,
|
self.SilverPaper,
|
self.ItemTypeID,
|
self.Count,
|
self.IsLocked,
|
self.ItemPlaceType,
|
self.ItemPlaceIndex,
|
self.IsBind,
|
self.ItemStarLV,
|
self.IdentifyPar,
|
self.CurDurg,
|
self.MaxDurg,
|
self.CanPlaceStoneCount,
|
self.ItemProperty,
|
self.SoulProperty,
|
self.Maker,
|
self.MakerName,
|
self.Stone1,
|
self.Stone2,
|
self.Stone3,
|
self.Stone4,
|
self.Stone5,
|
self.Stone6,
|
self.Stone7,
|
self.Stone8,
|
self.Stone9,
|
self.RemainHour,
|
self.CreateTime,
|
self.ElementEffect,
|
self.IsSuite,
|
self.FitLV,
|
self.EquipAddSkillCnt,
|
self.ExpireTime,
|
self.BaseAtkPlus,
|
self.BaseDefPlus,
|
self.AddSkillData,
|
self.BaseHP,
|
self.BaseMagicDef,
|
self.EquipMinAtkValue,
|
self.Proficiency,
|
self.RelMaxAddSkillCnt,
|
self.FamilyActiveValue,
|
self.UserDataLen,
|
self.UserData
|
)
|
return DumpString
|
|
class tagDMGetExpiationExResult(Structure):
|
Type = 0 #(BYTE Type)
|
Count = 0 #(BYTE Count)
|
Datas = list() #(vector<tagExpiation> Datas)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
for i in range(self.Count):
|
temDatas = tagExpiation()
|
_pos = temDatas.ReadData(_lpData, _pos)
|
self.Datas.append(temDatas)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.Count = 0
|
self.Datas = list()
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
for i in range(self.Count):
|
length += self.Datas[i].GetLength()
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.Count)
|
for i in range(self.Count):
|
data = CommFunc.WriteString(data, self.Datas[i].GetLength(), self.Datas[i].GetBuffer())
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
Count:%d,
|
Datas:%s
|
'''\
|
%(
|
self.Type,
|
self.Count,
|
"..."
|
)
|
return DumpString
|
|
|
#ÇëÇó´¦Àí½á¹û#tagDRequestResult
|
|
class tagDRequestResult(Structure):
|
Type = 0 #(BYTE Type)//ÇëÇóÀàÐÍ
|
Result = 0 #(BYTE Result)//´¦Àí½á¹û£¬ 0 ʧ°Ü£¬ 1 ³É¹¦
|
AccID = "" #(char AccID[65])//ÕʺÅÃû, ¸Ã½ÇÉ«ËùÔÚµÄÕʺŵÄÓû§Ãû
|
ExAttr = 0 #(BYTE ExAttr)// À©Õ¹×ֶΣ¬´¦Àíʧ°Üʱ±íʾʧ°ÜµÄÔÒò£¬Èç¹û³É¹¦£¬×ֶκ¯ÊýÒª¸ù¾Ý¾ßÌåµÄTypeÀ´¶¨
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.AccID,_pos = CommFunc.ReadString(_lpData, _pos,65)
|
self.ExAttr,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.Result = 0
|
self.AccID = ""
|
self.ExAttr = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 65
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.Result)
|
data = CommFunc.WriteString(data, 65, self.AccID)
|
data = CommFunc.WriteBYTE(data, self.ExAttr)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
Result:%d,
|
AccID:%s,
|
ExAttr:%d
|
'''\
|
%(
|
self.Type,
|
self.Result,
|
self.AccID,
|
self.ExAttr
|
)
|
return DumpString
|
|
#ÍÆËÍmap³äÖµ¶©µ¥ #tagDMRechargePush
|
|
class tagDMRechargePush(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
OrderIDLen = 0 #(BYTE OrderIDLen)
|
OrderID = "" #(String OrderID)// ¶©µ¥ºÅ
|
OrderInfoLen = 0 #(BYTE OrderInfoLen)
|
OrderInfo = "" #(String OrderInfo)// ¶©µ¥ÐÅÏ¢£¨ÉÌÆ·±àÂ룩
|
Money = 0 #(DWORD Money)//½ð¶î:·Ö
|
ExtrasLen = 0 #(BYTE ExtrasLen)
|
Extras = "" #(String Extras)// À©Õ¹ÐÅÏ¢
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderID,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderIDLen)
|
self.OrderInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderInfoLen)
|
self.Money,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ExtrasLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Extras,_pos = CommFunc.ReadString(_lpData, _pos,self.ExtrasLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.OrderIDLen = 0
|
self.OrderID = ""
|
self.OrderInfoLen = 0
|
self.OrderInfo = ""
|
self.Money = 0
|
self.ExtrasLen = 0
|
self.Extras = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.OrderID)
|
length += 1
|
length += len(self.OrderInfo)
|
length += 4
|
length += 1
|
length += len(self.Extras)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.SubType)
|
data = CommFunc.WriteBYTE(data, self.OrderIDLen)
|
data = CommFunc.WriteString(data, self.OrderIDLen, self.OrderID)
|
data = CommFunc.WriteBYTE(data, self.OrderInfoLen)
|
data = CommFunc.WriteString(data, self.OrderInfoLen, self.OrderInfo)
|
data = CommFunc.WriteDWORD(data, self.Money)
|
data = CommFunc.WriteBYTE(data, self.ExtrasLen)
|
data = CommFunc.WriteString(data, self.ExtrasLen, self.Extras)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
OrderIDLen:%d,
|
OrderID:%s,
|
OrderInfoLen:%d,
|
OrderInfo:%s,
|
Money:%d,
|
ExtrasLen:%d,
|
Extras:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.OrderIDLen,
|
self.OrderID,
|
self.OrderInfoLen,
|
self.OrderInfo,
|
self.Money,
|
self.ExtrasLen,
|
self.Extras
|
)
|
return DumpString
|
|
#»Ø¸´Ã½ÌåÐÂÊÖ¿¨ÊÇ·ñʹÓùý#tagDMIsMediaCardUsed
|
|
class tagDMIsMediaCardUsed(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
CardIDLen = 0 #(BYTE CardIDLen)
|
CardID = "" #(String CardID)// size = CardIDLen
|
IsUsed = 0 #(BYTE IsUsed)//ÊÇ·ñʹÓùý
|
UserDataLen = 0 #(DWORD UserDataLen)
|
UserData = "" #(String UserData)//size = UserDataLen
|
CardType = 0 #(BYTE CardType)
|
ValidTime = "" #(char ValidTime[20])//ÓÐЧÆÚ
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.CardIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.CardID,_pos = CommFunc.ReadString(_lpData, _pos,self.CardIDLen)
|
self.IsUsed,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
|
self.CardType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ValidTime,_pos = CommFunc.ReadString(_lpData, _pos,20)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.CardIDLen = 0
|
self.CardID = ""
|
self.IsUsed = 0
|
self.UserDataLen = 0
|
self.UserData = ""
|
self.CardType = 0
|
self.ValidTime = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.CardID)
|
length += 1
|
length += 4
|
length += len(self.UserData)
|
length += 1
|
length += 20
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.SubType)
|
data = CommFunc.WriteBYTE(data, self.CardIDLen)
|
data = CommFunc.WriteString(data, self.CardIDLen, self.CardID)
|
data = CommFunc.WriteBYTE(data, self.IsUsed)
|
data = CommFunc.WriteDWORD(data, self.UserDataLen)
|
data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
|
data = CommFunc.WriteBYTE(data, self.CardType)
|
data = CommFunc.WriteString(data, 20, self.ValidTime)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
CardIDLen:%d,
|
CardID:%s,
|
IsUsed:%d,
|
UserDataLen:%d,
|
UserData:%s,
|
CardType:%d,
|
ValidTime:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.CardIDLen,
|
self.CardID,
|
self.IsUsed,
|
self.UserDataLen,
|
self.UserData,
|
self.CardType,
|
self.ValidTime
|
)
|
return DumpString
|
|
#»Ø¸´¸üÐÂÐÂÊÖ¿¨×´Ì¬½á¹û#tagDMCheckUpdateMediaCardResult
|
|
class tagDMCheckUpdateMediaCardResult(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
CardIDLen = 0 #(BYTE CardIDLen)
|
CardID = "" #(String CardID)// size = CardIDLen
|
Result = 0 #(BYTE Result)//½á¹û¡£1³É¹¦£»0ʧ°Ü
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.CardIDLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.CardID,_pos = CommFunc.ReadString(_lpData, _pos,self.CardIDLen)
|
self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.CardIDLen = 0
|
self.CardID = ""
|
self.Result = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 1
|
length += len(self.CardID)
|
length += 1
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.SubType)
|
data = CommFunc.WriteBYTE(data, self.CardIDLen)
|
data = CommFunc.WriteString(data, self.CardIDLen, self.CardID)
|
data = CommFunc.WriteBYTE(data, self.Result)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
CardIDLen:%d,
|
CardID:%s,
|
Result:%d
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.CardIDLen,
|
self.CardID,
|
self.Result
|
)
|
return DumpString
|
|
|
|
#GMÃüÁîÖ´Ðнá¹û#tagGMCommandResult
|
|
class tagGMCommandResult(Structure):
|
Type = 0 #(BYTE Type)
|
OrderLen = 0 #(BYTE OrderLen)
|
OrderId = "" #(String OrderId)
|
ResultLen = 0 #(DWORD ResultLen)
|
Result = "" #(String Result)
|
UserDataLen = 0 #(DWORD UserDataLen)
|
UserData = "" #(String UserData)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.OrderId,_pos = CommFunc.ReadString(_lpData, _pos,self.OrderLen)
|
self.ResultLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultLen)
|
self.UserDataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.OrderLen = 0
|
self.OrderId = ""
|
self.ResultLen = 0
|
self.Result = ""
|
self.UserDataLen = 0
|
self.UserData = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += len(self.OrderId)
|
length += 4
|
length += len(self.Result)
|
length += 4
|
length += len(self.UserData)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.OrderLen)
|
data = CommFunc.WriteString(data, self.OrderLen, self.OrderId)
|
data = CommFunc.WriteDWORD(data, self.ResultLen)
|
data = CommFunc.WriteString(data, self.ResultLen, self.Result)
|
data = CommFunc.WriteDWORD(data, self.UserDataLen)
|
data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
OrderLen:%d,
|
OrderId:%s,
|
ResultLen:%d,
|
Result:%s,
|
UserDataLen:%d,
|
UserData:%s
|
'''\
|
%(
|
self.Type,
|
self.OrderLen,
|
self.OrderId,
|
self.ResultLen,
|
self.Result,
|
self.UserDataLen,
|
self.UserData
|
)
|
return DumpString
|
|
#GameServerͨÓÃÊý¾Ý¿â²Ù×÷½á¹û#tagDGGeneralDBOperResult
|
|
class tagDGGeneralDBOperResult(Structure):
|
Type = 0 #(BYTE Type)
|
Result = 0 #(BYTE Result)//½á¹û£º1³É¹¦£»0ʧ°Ü
|
ResultSetLen = 0 #(DWORD ResultSetLen)
|
ResultSet = "" #(String ResultSet)//½á¹û¼¯
|
ErrMsgLen = 0 #(DWORD ErrMsgLen)
|
ErrMsg = "" #(String ErrMsg)//´íÎóÐÅÏ¢
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Result,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ResultSetLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ResultSet,_pos = CommFunc.ReadString(_lpData, _pos,self.ResultSetLen)
|
self.ErrMsgLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ErrMsg,_pos = CommFunc.ReadString(_lpData, _pos,self.ErrMsgLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.Result = 0
|
self.ResultSetLen = 0
|
self.ResultSet = ""
|
self.ErrMsgLen = 0
|
self.ErrMsg = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 4
|
length += len(self.ResultSet)
|
length += 4
|
length += len(self.ErrMsg)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.Result)
|
data = CommFunc.WriteDWORD(data, self.ResultSetLen)
|
data = CommFunc.WriteString(data, self.ResultSetLen, self.ResultSet)
|
data = CommFunc.WriteDWORD(data, self.ErrMsgLen)
|
data = CommFunc.WriteString(data, self.ErrMsgLen, self.ErrMsg)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
Result:%d,
|
ResultSetLen:%d,
|
ResultSet:%s,
|
ErrMsgLen:%d,
|
ErrMsg:%s
|
'''\
|
%(
|
self.Type,
|
self.Result,
|
self.ResultSetLen,
|
self.ResultSet,
|
self.ErrMsgLen,
|
self.ErrMsg
|
)
|
return DumpString
|
|
#֪ͨGameServer¿ÉÓõļÒ×åIDÁбí#tagDGCanUseFamilyIDList
|
|
class tagDGCanUseFamilyIDList(Structure):
|
Type = 0 #(BYTE Type)
|
UpdateType = 0 #(BYTE UpdateType)//0Ϊ³õʼ»¯ÇëÇó£¬1ΪÊýÁ¿²»×ãʱ²¹³äÇëÇó
|
Count = 0 #(DWORD Count)
|
FamilyIDList = list() #(vector<DWORD> FamilyIDList)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.UpdateType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.Count,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
for i in range(self.Count):
|
value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
|
self.FamilyIDList.append(value)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.UpdateType = 0
|
self.Count = 0
|
self.FamilyIDList = list()
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 4
|
length += 4 * self.Count
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.UpdateType)
|
data = CommFunc.WriteDWORD(data, self.Count)
|
for i in range(self.Count):
|
data = CommFunc.WriteDWORD(data, self.FamilyIDList[i])
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
UpdateType:%d,
|
Count:%d,
|
FamilyIDList:%s
|
'''\
|
%(
|
self.Type,
|
self.UpdateType,
|
self.Count,
|
"..."
|
)
|
return DumpString
|
|
#¿ç·þ×Ó·þ¾´úÀíµ½Ö÷·þDBת·¢µ½Ö÷·þGameServer#tagDGMergerChildToGameStringData
|
|
class tagDGMergerChildToGameStringData(Structure):
|
Type = 0 #(BYTE Type)
|
DataLen = 0 #(DWORD DataLen)
|
Data = "" #(String Data)//×Ô¶¨ÒåÏûÏ¢
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.DataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
|
|
#------------------------------------------------------
|
#×Ó·þ»ã±¨Íæ¼ÒÊý¾Ý #tagDMMergePlayerData
|
|
class tagDMMergePlayerData(Structure):
|
Type = 0 #(BYTE Type)
|
SubType = 0 #(BYTE SubType)
|
PlayerID = 0 #(DWORD PlayerID)
|
DataLen = 0 #(DWORD DataLen)
|
Data = "" #(String Data)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.SubType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.DataLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.Data,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.SubType = 0
|
self.PlayerID = 0
|
self.DataLen = 0
|
self.Data = ""
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 1
|
length += 4
|
length += 4
|
length += len(self.Data)
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteBYTE(data, self.SubType)
|
data = CommFunc.WriteDWORD(data, self.PlayerID)
|
data = CommFunc.WriteDWORD(data, self.DataLen)
|
data = CommFunc.WriteString(data, self.DataLen, self.Data)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
SubType:%d,
|
PlayerID:%d,
|
DataLen:%d,
|
Data:%s
|
'''\
|
%(
|
self.Type,
|
self.SubType,
|
self.PlayerID,
|
self.DataLen,
|
self.Data
|
)
|
return DumpString
|
|
#------------------------------------------------------
|
#Íæ¼ÒµÇ½֪ͨµØͼÍæ¼Ò»ù±¾Êý¾Ý#tagMapServerPlayerLogin
|
|
class tagMapServerPlayerLogin(Structure):
|
Type = 0 #(BYTE Type)
|
ServerRoleIndex = 0 #(DWORD ServerRoleIndex)
|
SessionID = 0 #(DWORD SessionID)
|
ClientIP = "" #(char ClientIP[16])
|
PlayerInfoPackLen = 0 #(DWORD PlayerInfoPackLen)
|
PlayerInfoPack = "" #(String PlayerInfoPack)//size = PlayerInfoPackLen
|
PlayerAccountInfoLen = 0 #(WORD PlayerAccountInfoLen)
|
PlayerAccountInfo = "" #(String PlayerAccountInfo)//size = PlayerAccountInfoLen
|
MapID = 0 #(DWORD MapID)
|
data = None
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def ReadData(self, _lpData, _pos=0, _Len=0):
|
self.Clear()
|
self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
|
self.ServerRoleIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.SessionID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.ClientIP,_pos = CommFunc.ReadString(_lpData, _pos,16)
|
self.PlayerInfoPackLen,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
self.PlayerInfoPack,_pos = CommFunc.ReadString(_lpData, _pos,self.PlayerInfoPackLen)
|
self.PlayerAccountInfoLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
|
self.PlayerAccountInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.PlayerAccountInfoLen)
|
self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
|
return _pos
|
|
def Clear(self):
|
self.Type = 0
|
self.ServerRoleIndex = 0
|
self.SessionID = 0
|
self.ClientIP = ""
|
self.PlayerInfoPackLen = 0
|
self.PlayerInfoPack = ""
|
self.PlayerAccountInfoLen = 0
|
self.PlayerAccountInfo = ""
|
self.MapID = 0
|
return
|
|
def GetLength(self):
|
length = 0
|
length += 1
|
length += 4
|
length += 4
|
length += 16
|
length += 4
|
length += len(self.PlayerInfoPack)
|
length += 2
|
length += len(self.PlayerAccountInfo)
|
length += 4
|
|
return length
|
|
def GetBuffer(self):
|
data = ''
|
data = CommFunc.WriteBYTE(data, self.Type)
|
data = CommFunc.WriteDWORD(data, self.ServerRoleIndex)
|
data = CommFunc.WriteDWORD(data, self.SessionID)
|
data = CommFunc.WriteString(data, 16, self.ClientIP)
|
data = CommFunc.WriteDWORD(data, self.PlayerInfoPackLen)
|
data = CommFunc.WriteString(data, self.PlayerInfoPackLen, self.PlayerInfoPack)
|
data = CommFunc.WriteWORD(data, self.PlayerAccountInfoLen)
|
data = CommFunc.WriteString(data, self.PlayerAccountInfoLen, self.PlayerAccountInfo)
|
data = CommFunc.WriteDWORD(data, self.MapID)
|
return data
|
|
def OutputString(self):
|
DumpString = '''
|
Type:%d,
|
ServerRoleIndex:%d,
|
SessionID:%d,
|
ClientIP:%s,
|
PlayerInfoPackLen:%d,
|
PlayerInfoPack:%s,
|
PlayerAccountInfoLen:%d,
|
PlayerAccountInfo:%s,
|
MapID:%d
|
'''\
|
%(
|
self.Type,
|
self.ServerRoleIndex,
|
self.SessionID,
|
self.ClientIP,
|
self.PlayerInfoPackLen,
|
self.PlayerInfoPack,
|
self.PlayerAccountInfoLen,
|
self.PlayerAccountInfo,
|
self.MapID
|
)
|
return DumpString
|
|
|
#-----------------------------------------------------------------------------------------------------------
|
|
import binascii
|
from Common import (mylog, )
|
|
def test_tagServerGroupVersions():
|
obj1 = tagServerGroupVersions()
|
print 'sizeof(obj1) = %s'%obj1.GetLength()
|
print 'obj1.OutputString() = %s'%obj1.OutputString()
|
|
obj2 = tagServerGroupVersions()
|
obj2.Type = 1
|
obj2.VersionCnt = 2
|
VersionList = []
|
# obj2.setVersionCnt(2)
|
# resize(obj2.VersionList, sizeof(tagServerGroupVersion) * obj2.VersionCnt)
|
for i in xrange(obj2.VersionCnt):
|
version = tagServerGroupVersion()
|
version.MajorVersion = 3 + i
|
version.MinorVersion = 4 + i
|
version.LanguageVersion = 5 + i
|
VersionList.append(version)
|
obj2.VersionList = (tagServerGroupVersion * obj2.VersionCnt)(*VersionList)
|
print 'obj2.OutputString() = %s'%obj2.OutputString()
|
|
pos = 0
|
obj1.ReadData(obj2.GetBuffer(), pos, obj2.GetLength())
|
print 'obj1.OutputString() = %s'%obj1.OutputString()
|
|
def test():
|
mylog.InitMyLog('test_SendPackProtocol.log')
|
|
xDServerValueType = tagDServerValueType()
|
mylog.info('init %s'%xDServerValueType.outputString())
|
|
mylog.info('xDServerValueType.getLength() = %s'%xDServerValueType.getLength())
|
|
xDServerValueType.Type = 1
|
xDServerValueType.Value = 2
|
mylog.info('buf = %s'%binascii.b2a_hex(xDServerValueType.getBuffer()))
|
|
xDServerValueType1 = tagDServerValueType()
|
mylog.info('init %s'%xDServerValueType1.outputString())
|
pos = 0
|
readLen = xDServerValueType1.readData(xDServerValueType.getBuffer(), pos, xDServerValueType.getLength())
|
if readLen <= 0:
|
mylog.error('error in readData')
|
return
|
mylog.info('readLen = %s'%readLen)
|
mylog.info('after readData:%s'%xDServerValueType1.outputString())
|
|
if __name__ == '__main__':
|
# test()
|
test_tagServerGroupVersions()
|
|
|
|
|
