16 卡牌服务端（功能队伍数据基础；不含功能逻辑；）

hxp

2025-05-28 a6fe9b060edf315f6abde7443e48db5dea439f47

16 卡牌服务端（功能队伍数据基础；不含功能逻辑；）

 PySysDB/PySysDBPY.h

@@ -12,6 +12,20 @@
    char        Word;    //屏蔽词

};



//功能队伍设定表



struct tagFuncTeamSet

{

    DWORD        _FuncMapID;    //功能地图ID

    BYTE        NeedName;    //需要队伍名

    BYTE        MemberMax;    //最大人员数

    BYTE        ApplyMax;    //最大接受申请数

    BYTE        ReqApplyMax;    //最大申请数

    BYTE        SortType;    //队伍列表排序方案

    BYTE        SortReverse;    //是否倒序

    BYTE        OPLimitInAct;    //活动期间限制队伍操作

};



//称号表 #tagDienstgrad



struct    tagDienstgrad


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/PyNetPack.ini

@@ -58,6 +58,34 @@
PacketSubCMD_1=0x30

PacketCallFunc_1=OnViewBillboard



;功能组队

[PlayerFuncTeam]

ScriptName = Player\PlayerFuncTeam.py

Writer = hxp

Releaser = hxp

RegType = 0

RegisterPackCount = 5



PacketCMD_1=0xB9

PacketSubCMD_1=0x20

PacketCallFunc_1=OnCreateFuncTeam



PacketCMD_2=0xB9

PacketSubCMD_2=0x21

PacketCallFunc_2=OnChangeFuncTeam



PacketCMD_3=0xB9

PacketSubCMD_3=0x22

PacketCallFunc_3=OnFuncTeamMemOP



PacketCMD_4=0xB9

PacketSubCMD_4=0x23

PacketCallFunc_4=OnQueryFuncTeam



PacketCMD_5=0xB9

PacketSubCMD_5=0x24

PacketCallFunc_5=OnQueryPlayerFuncTeam



;法器

[PlayerFaQi]

ScriptName = Player\PlayerFaQi.py


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChPyNetPack.py

@@ -22932,6 +22932,82 @@




#------------------------------------------------------

# B9 21 修改功能队伍 #tagCMChangeFuncTeam



class  tagCMChangeFuncTeam(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("TeamID", c_int),    
                  ("FuncMapID", c_int),    # 功能地图ID或自定义的活动功能ID

                  ("MinLV", c_ushort),    #最低等级限制

                  ("MinFightPower", c_int),    #最低战力限制，求余亿

                  ("MinFightPowerEx", c_int),    #最低战力限制，整除亿

                  ("ServerOnly", c_ubyte),    #是否仅本服玩家可加入，0-否，1-是

                  ("NeedCheck", c_ubyte),    #是否需要审核

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xB9

        self.SubCmd = 0x21

        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 = 0xB9

        self.SubCmd = 0x21

        self.TeamID = 0

        self.FuncMapID = 0

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        return



    def GetLength(self):

        return sizeof(tagCMChangeFuncTeam)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// B9 21 修改功能队伍 //tagCMChangeFuncTeam:

                                Cmd:%s,

                                SubCmd:%s,

                                TeamID:%d,

                                FuncMapID:%d,

                                MinLV:%d,

                                MinFightPower:%d,

                                MinFightPowerEx:%d,

                                ServerOnly:%d,

                                NeedCheck:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.TeamID,

                                self.FuncMapID,

                                self.MinLV,

                                self.MinFightPower,

                                self.MinFightPowerEx,

                                self.ServerOnly,

                                self.NeedCheck

                                )

        return DumpString





m_NAtagCMChangeFuncTeam=tagCMChangeFuncTeam()

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





#------------------------------------------------------

# B9 04 修改队伍相关审核状态 #tagCMChangeTeamCheckState



class  tagCMChangeTeamCheckState(Structure):

@@ -22988,6 +23064,341 @@




#------------------------------------------------------

# B9 20 创建功能队伍 #tagCMCreateFuncTeam



class  tagCMCreateFuncTeam(Structure):

    Head = tagHead()

    FuncMapID = 0    #(DWORD FuncMapID)// 功能地图ID或自定义的活动功能ID

    FuncMapEx = 0    #(DWORD FuncMapEx)// 功能地图扩展，如不同的层级

    NameLen = 0    #(BYTE NameLen)

    TeamName = ""    #(String TeamName)// 队伍名称，可为空

    MinLV = 0    #(WORD MinLV)//最低等级限制

    MinFightPower = 0    #(DWORD MinFightPower)//最低战力限制，求余亿

    MinFightPowerEx = 0    #(DWORD MinFightPowerEx)//最低战力限制，整除亿

    ServerOnly = 0    #(BYTE ServerOnly)//是否仅本服玩家可加入，0-否，1-是

    NeedCheck = 0    #(BYTE NeedCheck)//是否需要审核

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x20

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.TeamName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.MinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.MinFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MinFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.NeedCheck,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x20

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.NameLen = 0

        self.TeamName = ""

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 4

        length += 4

        length += 1

        length += len(self.TeamName)

        length += 2

        length += 4

        length += 4

        length += 1

        length += 1



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteDWORD(data, self.FuncMapID)

        data = CommFunc.WriteDWORD(data, self.FuncMapEx)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.TeamName)

        data = CommFunc.WriteWORD(data, self.MinLV)

        data = CommFunc.WriteDWORD(data, self.MinFightPower)

        data = CommFunc.WriteDWORD(data, self.MinFightPowerEx)

        data = CommFunc.WriteBYTE(data, self.ServerOnly)

        data = CommFunc.WriteBYTE(data, self.NeedCheck)

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                FuncMapID:%d,

                                FuncMapEx:%d,

                                NameLen:%d,

                                TeamName:%s,

                                MinLV:%d,

                                MinFightPower:%d,

                                MinFightPowerEx:%d,

                                ServerOnly:%d,

                                NeedCheck:%d

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.FuncMapID,

                                self.FuncMapEx,

                                self.NameLen,

                                self.TeamName,

                                self.MinLV,

                                self.MinFightPower,

                                self.MinFightPowerEx,

                                self.ServerOnly,

                                self.NeedCheck

                                )

        return DumpString





m_NAtagCMCreateFuncTeam=tagCMCreateFuncTeam()

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





#------------------------------------------------------

# B9 22 功能队伍成员操作 #tagCMFuncTeamMemOP



class  tagCMFuncTeamMemOP(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("TeamID", c_int),    
                  ("FuncMapID", c_int),    # 功能地图ID或自定义的活动功能ID

                  ("OPType", c_ubyte),    # 1-申请加入；2-申请取消；3-同意入队；4-拒绝入队；5-退出队伍；6-踢出队伍；7-转让队长；8-解散队伍；

                  ("OPData", c_int),    # 可选

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xB9

        self.SubCmd = 0x22

        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 = 0xB9

        self.SubCmd = 0x22

        self.TeamID = 0

        self.FuncMapID = 0

        self.OPType = 0

        self.OPData = 0

        return



    def GetLength(self):

        return sizeof(tagCMFuncTeamMemOP)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// B9 22 功能队伍成员操作 //tagCMFuncTeamMemOP:

                                Cmd:%s,

                                SubCmd:%s,

                                TeamID:%d,

                                FuncMapID:%d,

                                OPType:%d,

                                OPData:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.TeamID,

                                self.FuncMapID,

                                self.OPType,

                                self.OPData

                                )

        return DumpString





m_NAtagCMFuncTeamMemOP=tagCMFuncTeamMemOP()

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





#------------------------------------------------------

# B9 23 查找功能队伍列表 #tagCMQueryFuncTeam



class  tagCMQueryFuncTeam(Structure):

    Head = tagHead()

    FuncMapID = 0    #(DWORD FuncMapID)// 功能地图ID或自定义的活动功能ID

    FuncMapEx = 0    #(DWORD FuncMapEx)// 功能地图扩展，如不同的层级，0代表所有

    StartIndex = 0    #(DWORD StartIndex)// 查看的起始索引， 默认0

    QueryCnt = 0    #(BYTE QueryCnt)// 查看条数，默认20，最大不超过100

    HaveSpace = 0    #(BYTE HaveSpace)// 是否只查看有空位置的队伍

    IDLimitType = 0    #(BYTE IDLimitType)// ID限制类型：1-同仙盟队长；2-同ServerGroupID队长；3-同ServerID队长

    SearchLen = 0    #(BYTE SearchLen)

    SearchMsg = ""    #(String SearchMsg)// 指定搜索时有用，可搜索指定队伍ID或模糊搜索队伍名称，搜索时返回最多QueryCnt个数的队伍

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x23

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.StartIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.QueryCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.HaveSpace,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.IDLimitType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SearchLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SearchMsg,_pos = CommFunc.ReadString(_lpData, _pos,self.SearchLen)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x23

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.StartIndex = 0

        self.QueryCnt = 0

        self.HaveSpace = 0

        self.IDLimitType = 0

        self.SearchLen = 0

        self.SearchMsg = ""

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 4

        length += 4

        length += 4

        length += 1

        length += 1

        length += 1

        length += 1

        length += len(self.SearchMsg)



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteDWORD(data, self.FuncMapID)

        data = CommFunc.WriteDWORD(data, self.FuncMapEx)

        data = CommFunc.WriteDWORD(data, self.StartIndex)

        data = CommFunc.WriteBYTE(data, self.QueryCnt)

        data = CommFunc.WriteBYTE(data, self.HaveSpace)

        data = CommFunc.WriteBYTE(data, self.IDLimitType)

        data = CommFunc.WriteBYTE(data, self.SearchLen)

        data = CommFunc.WriteString(data, self.SearchLen, self.SearchMsg)

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                FuncMapID:%d,

                                FuncMapEx:%d,

                                StartIndex:%d,

                                QueryCnt:%d,

                                HaveSpace:%d,

                                IDLimitType:%d,

                                SearchLen:%d,

                                SearchMsg:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.FuncMapID,

                                self.FuncMapEx,

                                self.StartIndex,

                                self.QueryCnt,

                                self.HaveSpace,

                                self.IDLimitType,

                                self.SearchLen,

                                self.SearchMsg

                                )

        return DumpString





m_NAtagCMQueryFuncTeam=tagCMQueryFuncTeam()

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





#------------------------------------------------------

# B9 24 查找玩家功能队伍 #tagCMQueryPlayerFuncTeam



class  tagCMQueryPlayerFuncTeam(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("FuncMapID", c_int),    # 功能地图ID或自定义的活动功能ID

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xB9

        self.SubCmd = 0x24

        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 = 0xB9

        self.SubCmd = 0x24

        self.FuncMapID = 0

        return



    def GetLength(self):

        return sizeof(tagCMQueryPlayerFuncTeam)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// B9 24 查找玩家功能队伍 //tagCMQueryPlayerFuncTeam:

                                Cmd:%s,

                                SubCmd:%s,

                                FuncMapID:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.FuncMapID

                                )

        return DumpString





m_NAtagCMQueryPlayerFuncTeam=tagCMQueryPlayerFuncTeam()

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





#------------------------------------------------------

# C1 22 跨服排位竞猜 #tagCMChampionshipGuess



class  tagCMChampionshipGuess(Structure):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChPyNetSendPack.py

@@ -60394,6 +60394,959 @@




#------------------------------------------------------

# B9 23 功能队伍解散 #tagMCFuncTeamDissolve



class  tagMCFuncTeamDissolve(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("TeamID", c_int),    
                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xB9

        self.SubCmd = 0x23

        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 = 0xB9

        self.SubCmd = 0x23

        self.TeamID = 0

        return



    def GetLength(self):

        return sizeof(tagMCFuncTeamDissolve)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// B9 23 功能队伍解散 //tagMCFuncTeamDissolve:

                                Cmd:%s,

                                SubCmd:%s,

                                TeamID:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.TeamID

                                )

        return DumpString





m_NAtagMCFuncTeamDissolve=tagMCFuncTeamDissolve()

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





#------------------------------------------------------

# B9 22 功能队伍列表 #tagMCFuncTeamList



class  tagMCFuncTeamMem(Structure):

    ServerID = 0    #(DWORD ServerID)

    PlayerID = 0    #(DWORD PlayerID)

    NameLen = 0    #(BYTE NameLen)

    Name = ""    #(String Name)// 玩家名，size = NameLen

    LV = 0    #(WORD LV)// 玩家等级

    Job = 0    #(BYTE Job)// 玩家职业

    RealmLV = 0    #(WORD RealmLV)// 玩家境界

    Face = 0    #(DWORD Face)//基本脸型

    FacePic = 0    #(DWORD FacePic)//头像框

    FightPower = 0    #(DWORD FightPower)// 战力，求余亿

    FightPowerEx = 0    #(DWORD FightPowerEx)// 战力，整除亿

    Value1 = 0    #(DWORD Value1)//ֵ1

    Value2 = 0    #(DWORD Value2)//ֵ2

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        return _pos



    def Clear(self):

        self.ServerID = 0

        self.PlayerID = 0

        self.NameLen = 0

        self.Name = ""

        self.LV = 0

        self.Job = 0

        self.RealmLV = 0

        self.Face = 0

        self.FacePic = 0

        self.FightPower = 0

        self.FightPowerEx = 0

        self.Value1 = 0

        self.Value2 = 0

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 4

        length += 1

        length += len(self.Name)

        length += 2

        length += 1

        length += 2

        length += 4

        length += 4

        length += 4

        length += 4

        length += 4

        length += 4



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.ServerID)

        data = CommFunc.WriteDWORD(data, self.PlayerID)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.Name)

        data = CommFunc.WriteWORD(data, self.LV)

        data = CommFunc.WriteBYTE(data, self.Job)

        data = CommFunc.WriteWORD(data, self.RealmLV)

        data = CommFunc.WriteDWORD(data, self.Face)

        data = CommFunc.WriteDWORD(data, self.FacePic)

        data = CommFunc.WriteDWORD(data, self.FightPower)

        data = CommFunc.WriteDWORD(data, self.FightPowerEx)

        data = CommFunc.WriteDWORD(data, self.Value1)

        data = CommFunc.WriteDWORD(data, self.Value2)

        return data



    def OutputString(self):

        DumpString = '''

                                ServerID:%d,

                                PlayerID:%d,

                                NameLen:%d,

                                Name:%s,

                                LV:%d,

                                Job:%d,

                                RealmLV:%d,

                                Face:%d,

                                FacePic:%d,

                                FightPower:%d,

                                FightPowerEx:%d,

                                Value1:%d,

                                Value2:%d

                                '''\

                                %(

                                self.ServerID,

                                self.PlayerID,

                                self.NameLen,

                                self.Name,

                                self.LV,

                                self.Job,

                                self.RealmLV,

                                self.Face,

                                self.FacePic,

                                self.FightPower,

                                self.FightPowerEx,

                                self.Value1,

                                self.Value2

                                )

        return DumpString





class  tagMCFuncTeam(Structure):

    TeamID = 0    #(DWORD TeamID)

    CreateTime = 0    #(DWORD CreateTime)//创建队伍时间戳

    FuncMapEx = 0    #(DWORD FuncMapEx)//功能地图扩展，如不同的层级

    NameLen = 0    #(BYTE NameLen)

    TeamName = ""    #(String TeamName)//队伍名称

    CaptainID = 0    #(DWORD CaptainID)//队长ID，队伍ServerID直接取队长的ServerID

    MinLV = 0    #(WORD MinLV)//最低等级限制

    MinFightPower = 0    #(DWORD MinFightPower)//最低战力限制，求余亿

    MinFightPowerEx = 0    #(DWORD MinFightPowerEx)//最低战力限制，整除亿

    ServerOnly = 0    #(BYTE ServerOnly)//是否仅本服玩家可加入，0-否，1-是

    NeedCheck = 0    #(BYTE NeedCheck)//是否需要审核

    Value1 = 0    #(DWORD Value1)//ֵ1

    Value2 = 0    #(DWORD Value2)//ֵ2

    MemberCount = 0    #(BYTE MemberCount)

    MemberList = list()    #(vector<tagMCFuncTeamMem> MemberList)// 成员列表

    ApplyCount = 0    #(WORD ApplyCount)

    ApplyIDList = list()    #(vector<DWORD> ApplyIDList)// 申请玩家ID列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CreateTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.TeamName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.CaptainID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.MinFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MinFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.NeedCheck,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.MemberCount):

            temMemberList = tagMCFuncTeamMem()

            _pos = temMemberList.ReadData(_lpData, _pos)

            self.MemberList.append(temMemberList)

        self.ApplyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)

        for i in range(self.ApplyCount):

            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)

            self.ApplyIDList.append(value)

        return _pos



    def Clear(self):

        self.TeamID = 0

        self.CreateTime = 0

        self.FuncMapEx = 0

        self.NameLen = 0

        self.TeamName = ""

        self.CaptainID = 0

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        self.Value1 = 0

        self.Value2 = 0

        self.MemberCount = 0

        self.MemberList = list()

        self.ApplyCount = 0

        self.ApplyIDList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 4

        length += 4

        length += 1

        length += len(self.TeamName)

        length += 4

        length += 2

        length += 4

        length += 4

        length += 1

        length += 1

        length += 4

        length += 4

        length += 1

        for i in range(self.MemberCount):

            length += self.MemberList[i].GetLength()

        length += 2

        length += 4 * self.ApplyCount



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.TeamID)

        data = CommFunc.WriteDWORD(data, self.CreateTime)

        data = CommFunc.WriteDWORD(data, self.FuncMapEx)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.TeamName)

        data = CommFunc.WriteDWORD(data, self.CaptainID)

        data = CommFunc.WriteWORD(data, self.MinLV)

        data = CommFunc.WriteDWORD(data, self.MinFightPower)

        data = CommFunc.WriteDWORD(data, self.MinFightPowerEx)

        data = CommFunc.WriteBYTE(data, self.ServerOnly)

        data = CommFunc.WriteBYTE(data, self.NeedCheck)

        data = CommFunc.WriteDWORD(data, self.Value1)

        data = CommFunc.WriteDWORD(data, self.Value2)

        data = CommFunc.WriteBYTE(data, self.MemberCount)

        for i in range(self.MemberCount):

            data = CommFunc.WriteString(data, self.MemberList[i].GetLength(), self.MemberList[i].GetBuffer())

        data = CommFunc.WriteWORD(data, self.ApplyCount)

        for i in range(self.ApplyCount):

            data = CommFunc.WriteDWORD(data, self.ApplyIDList[i])

        return data



    def OutputString(self):

        DumpString = '''

                                TeamID:%d,

                                CreateTime:%d,

                                FuncMapEx:%d,

                                NameLen:%d,

                                TeamName:%s,

                                CaptainID:%d,

                                MinLV:%d,

                                MinFightPower:%d,

                                MinFightPowerEx:%d,

                                ServerOnly:%d,

                                NeedCheck:%d,

                                Value1:%d,

                                Value2:%d,

                                MemberCount:%d,

                                MemberList:%s,

                                ApplyCount:%d,

                                ApplyIDList:%s

                                '''\

                                %(

                                self.TeamID,

                                self.CreateTime,

                                self.FuncMapEx,

                                self.NameLen,

                                self.TeamName,

                                self.CaptainID,

                                self.MinLV,

                                self.MinFightPower,

                                self.MinFightPowerEx,

                                self.ServerOnly,

                                self.NeedCheck,

                                self.Value1,

                                self.Value2,

                                self.MemberCount,

                                "...",

                                self.ApplyCount,

                                "..."

                                )

        return DumpString





class  tagMCFuncTeamList(Structure):

    Head = tagHead()

    FuncMapID = 0    #(DWORD FuncMapID)// 功能地图ID或自定义的活动功能ID

    FuncMapEx = 0    #(DWORD FuncMapEx)// 功能地图扩展，如不同的层级，0代表所有

    StartIndex = 0    #(DWORD StartIndex)// 查看的起始索引， 默认0

    QueryCnt = 0    #(BYTE QueryCnt)// 查看条数，默认20，最大不超过100

    HaveSpace = 0    #(BYTE HaveSpace)// 是否只查看有空位置的队伍

    IDLimitType = 0    #(BYTE IDLimitType)// ID限制类型：1-同仙盟队长；2-同ServerGroupID队长；3-同ServerID队长

    SearchLen = 0    #(BYTE SearchLen)

    SearchMsg = ""    #(String SearchMsg)// 指定搜索时有用，可搜索指定队伍ID或模糊搜索队伍名称，搜索时返回最多QueryCnt个数的队伍

    LoopIndex = 0    #(DWORD LoopIndex)// 服务器检索到的索引，列表下拉时下一个查询包的StartIndex从这个LoopIndex开始

    TeamCount = 0    #(BYTE TeamCount)// 如果返回的队伍数小于QueryCnt，代表服务器已经没有满足条件的队伍了，列表再下拉时不再发查询包

    TeamList = list()    #(vector<tagMCFuncTeam> TeamList)

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x22

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.StartIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.QueryCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.HaveSpace,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.IDLimitType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SearchLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SearchMsg,_pos = CommFunc.ReadString(_lpData, _pos,self.SearchLen)

        self.LoopIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.TeamCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.TeamCount):

            temTeamList = tagMCFuncTeam()

            _pos = temTeamList.ReadData(_lpData, _pos)

            self.TeamList.append(temTeamList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x22

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.StartIndex = 0

        self.QueryCnt = 0

        self.HaveSpace = 0

        self.IDLimitType = 0

        self.SearchLen = 0

        self.SearchMsg = ""

        self.LoopIndex = 0

        self.TeamCount = 0

        self.TeamList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 4

        length += 4

        length += 4

        length += 1

        length += 1

        length += 1

        length += 1

        length += len(self.SearchMsg)

        length += 4

        length += 1

        for i in range(self.TeamCount):

            length += self.TeamList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteDWORD(data, self.FuncMapID)

        data = CommFunc.WriteDWORD(data, self.FuncMapEx)

        data = CommFunc.WriteDWORD(data, self.StartIndex)

        data = CommFunc.WriteBYTE(data, self.QueryCnt)

        data = CommFunc.WriteBYTE(data, self.HaveSpace)

        data = CommFunc.WriteBYTE(data, self.IDLimitType)

        data = CommFunc.WriteBYTE(data, self.SearchLen)

        data = CommFunc.WriteString(data, self.SearchLen, self.SearchMsg)

        data = CommFunc.WriteDWORD(data, self.LoopIndex)

        data = CommFunc.WriteBYTE(data, self.TeamCount)

        for i in range(self.TeamCount):

            data = CommFunc.WriteString(data, self.TeamList[i].GetLength(), self.TeamList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                FuncMapID:%d,

                                FuncMapEx:%d,

                                StartIndex:%d,

                                QueryCnt:%d,

                                HaveSpace:%d,

                                IDLimitType:%d,

                                SearchLen:%d,

                                SearchMsg:%s,

                                LoopIndex:%d,

                                TeamCount:%d,

                                TeamList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.FuncMapID,

                                self.FuncMapEx,

                                self.StartIndex,

                                self.QueryCnt,

                                self.HaveSpace,

                                self.IDLimitType,

                                self.SearchLen,

                                self.SearchMsg,

                                self.LoopIndex,

                                self.TeamCount,

                                "..."

                                )

        return DumpString





m_NAtagMCFuncTeamList=tagMCFuncTeamList()

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





#------------------------------------------------------

# B9 20 功能队伍刷新 #tagMCFuncTeamRefresh



class  tagMCFuncTeamRefreshApply(Structure):

    ServerID = 0    #(DWORD ServerID)

    PlayerID = 0    #(DWORD PlayerID)

    NameLen = 0    #(BYTE NameLen)

    Name = ""    #(String Name)// 玩家名，size = NameLen

    LV = 0    #(WORD LV)// 玩家等级

    Job = 0    #(BYTE Job)// 玩家职业

    RealmLV = 0    #(WORD RealmLV)// 玩家境界

    Face = 0    #(DWORD Face)//基本脸型

    FacePic = 0    #(DWORD FacePic)//头像框

    FightPower = 0    #(DWORD FightPower)// 战力，求余亿

    FightPowerEx = 0    #(DWORD FightPowerEx)// 战力，整除亿

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        return _pos



    def Clear(self):

        self.ServerID = 0

        self.PlayerID = 0

        self.NameLen = 0

        self.Name = ""

        self.LV = 0

        self.Job = 0

        self.RealmLV = 0

        self.Face = 0

        self.FacePic = 0

        self.FightPower = 0

        self.FightPowerEx = 0

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 4

        length += 1

        length += len(self.Name)

        length += 2

        length += 1

        length += 2

        length += 4

        length += 4

        length += 4

        length += 4



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.ServerID)

        data = CommFunc.WriteDWORD(data, self.PlayerID)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.Name)

        data = CommFunc.WriteWORD(data, self.LV)

        data = CommFunc.WriteBYTE(data, self.Job)

        data = CommFunc.WriteWORD(data, self.RealmLV)

        data = CommFunc.WriteDWORD(data, self.Face)

        data = CommFunc.WriteDWORD(data, self.FacePic)

        data = CommFunc.WriteDWORD(data, self.FightPower)

        data = CommFunc.WriteDWORD(data, self.FightPowerEx)

        return data



    def OutputString(self):

        DumpString = '''

                                ServerID:%d,

                                PlayerID:%d,

                                NameLen:%d,

                                Name:%s,

                                LV:%d,

                                Job:%d,

                                RealmLV:%d,

                                Face:%d,

                                FacePic:%d,

                                FightPower:%d,

                                FightPowerEx:%d

                                '''\

                                %(

                                self.ServerID,

                                self.PlayerID,

                                self.NameLen,

                                self.Name,

                                self.LV,

                                self.Job,

                                self.RealmLV,

                                self.Face,

                                self.FacePic,

                                self.FightPower,

                                self.FightPowerEx

                                )

        return DumpString





class  tagMCFuncTeamRefreshMem(Structure):

    ServerID = 0    #(DWORD ServerID)

    PlayerID = 0    #(DWORD PlayerID)

    NameLen = 0    #(BYTE NameLen)

    Name = ""    #(String Name)// 玩家名，size = NameLen

    LV = 0    #(WORD LV)// 玩家等级

    Job = 0    #(BYTE Job)// 玩家职业

    RealmLV = 0    #(WORD RealmLV)// 玩家境界

    Face = 0    #(DWORD Face)//基本脸型

    FacePic = 0    #(DWORD FacePic)//头像框

    FightPower = 0    #(DWORD FightPower)// 战力，求余亿

    FightPowerEx = 0    #(DWORD FightPowerEx)// 战力，整除亿

    OfflineValue = 0    #(DWORD OfflineValue)// 离线值：0-在线；1-离线；>1-上次离线时间戳，可用于计算离线多久了；当取不到玩家信息时用1代表已离线；

    Value1 = 0    #(DWORD Value1)//ֵ1

    Value2 = 0    #(DWORD Value2)//ֵ2

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.OfflineValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        return _pos



    def Clear(self):

        self.ServerID = 0

        self.PlayerID = 0

        self.NameLen = 0

        self.Name = ""

        self.LV = 0

        self.Job = 0

        self.RealmLV = 0

        self.Face = 0

        self.FacePic = 0

        self.FightPower = 0

        self.FightPowerEx = 0

        self.OfflineValue = 0

        self.Value1 = 0

        self.Value2 = 0

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 4

        length += 1

        length += len(self.Name)

        length += 2

        length += 1

        length += 2

        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.ServerID)

        data = CommFunc.WriteDWORD(data, self.PlayerID)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.Name)

        data = CommFunc.WriteWORD(data, self.LV)

        data = CommFunc.WriteBYTE(data, self.Job)

        data = CommFunc.WriteWORD(data, self.RealmLV)

        data = CommFunc.WriteDWORD(data, self.Face)

        data = CommFunc.WriteDWORD(data, self.FacePic)

        data = CommFunc.WriteDWORD(data, self.FightPower)

        data = CommFunc.WriteDWORD(data, self.FightPowerEx)

        data = CommFunc.WriteDWORD(data, self.OfflineValue)

        data = CommFunc.WriteDWORD(data, self.Value1)

        data = CommFunc.WriteDWORD(data, self.Value2)

        return data



    def OutputString(self):

        DumpString = '''

                                ServerID:%d,

                                PlayerID:%d,

                                NameLen:%d,

                                Name:%s,

                                LV:%d,

                                Job:%d,

                                RealmLV:%d,

                                Face:%d,

                                FacePic:%d,

                                FightPower:%d,

                                FightPowerEx:%d,

                                OfflineValue:%d,

                                Value1:%d,

                                Value2:%d

                                '''\

                                %(

                                self.ServerID,

                                self.PlayerID,

                                self.NameLen,

                                self.Name,

                                self.LV,

                                self.Job,

                                self.RealmLV,

                                self.Face,

                                self.FacePic,

                                self.FightPower,

                                self.FightPowerEx,

                                self.OfflineValue,

                                self.Value1,

                                self.Value2

                                )

        return DumpString





class  tagMCFuncTeamRefresh(Structure):

    Head = tagHead()

    TeamID = 0    #(DWORD TeamID)

    CreateTime = 0    #(DWORD CreateTime)//创建队伍时间戳

    FuncMapID = 0    #(DWORD FuncMapID)// 功能地图ID或自定义的活动功能ID

    FuncMapEx = 0    #(DWORD FuncMapEx)// 功能地图扩展，如不同的层级

    NameLen = 0    #(BYTE NameLen)

    TeamName = ""    #(String TeamName)// 队伍名称

    CaptainID = 0    #(DWORD CaptainID)//队长ID，队伍ServerID直接取队长的ServerID

    MinLV = 0    #(WORD MinLV)//最低等级限制

    MinFightPower = 0    #(DWORD MinFightPower)//最低战力限制，求余亿

    MinFightPowerEx = 0    #(DWORD MinFightPowerEx)//最低战力限制，整除亿

    ServerOnly = 0    #(BYTE ServerOnly)//是否仅本服玩家可加入，0-否，1-是

    NeedCheck = 0    #(BYTE NeedCheck)//是否需要审核

    Value1 = 0    #(DWORD Value1)//ֵ1

    Value2 = 0    #(DWORD Value2)//ֵ2

    MemberCount = 0    #(BYTE MemberCount)

    MemberList = list()    #(vector<tagMCFuncTeamRefreshMem> MemberList)// 成员列表

    ApplyCount = 0    #(WORD ApplyCount)

    ApplyIDList = list()    #(vector<DWORD> ApplyIDList)// 申请玩家ID列表

    ApplyInfoList = list()    #(vector<tagMCFuncTeamRefreshApply> ApplyInfoList)// 申请玩家明细列表

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x20

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.TeamID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CreateTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.FuncMapEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.TeamName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)

        self.CaptainID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MinLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.MinFightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MinFightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.NeedCheck,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.MemberCount):

            temMemberList = tagMCFuncTeamRefreshMem()

            _pos = temMemberList.ReadData(_lpData, _pos)

            self.MemberList.append(temMemberList)

        self.ApplyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)

        for i in range(self.ApplyCount):

            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)

            self.ApplyIDList.append(value)

        for i in range(self.ApplyCount):

            temApplyInfoList = tagMCFuncTeamRefreshApply()

            _pos = temApplyInfoList.ReadData(_lpData, _pos)

            self.ApplyInfoList.append(temApplyInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xB9

        self.Head.SubCmd = 0x20

        self.TeamID = 0

        self.CreateTime = 0

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.NameLen = 0

        self.TeamName = ""

        self.CaptainID = 0

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        self.Value1 = 0

        self.Value2 = 0

        self.MemberCount = 0

        self.MemberList = list()

        self.ApplyCount = 0

        self.ApplyIDList = list()

        self.ApplyInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 4

        length += 4

        length += 4

        length += 4

        length += 1

        length += len(self.TeamName)

        length += 4

        length += 2

        length += 4

        length += 4

        length += 1

        length += 1

        length += 4

        length += 4

        length += 1

        for i in range(self.MemberCount):

            length += self.MemberList[i].GetLength()

        length += 2

        length += 4 * self.ApplyCount

        for i in range(self.ApplyCount):

            length += self.ApplyInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteDWORD(data, self.TeamID)

        data = CommFunc.WriteDWORD(data, self.CreateTime)

        data = CommFunc.WriteDWORD(data, self.FuncMapID)

        data = CommFunc.WriteDWORD(data, self.FuncMapEx)

        data = CommFunc.WriteBYTE(data, self.NameLen)

        data = CommFunc.WriteString(data, self.NameLen, self.TeamName)

        data = CommFunc.WriteDWORD(data, self.CaptainID)

        data = CommFunc.WriteWORD(data, self.MinLV)

        data = CommFunc.WriteDWORD(data, self.MinFightPower)

        data = CommFunc.WriteDWORD(data, self.MinFightPowerEx)

        data = CommFunc.WriteBYTE(data, self.ServerOnly)

        data = CommFunc.WriteBYTE(data, self.NeedCheck)

        data = CommFunc.WriteDWORD(data, self.Value1)

        data = CommFunc.WriteDWORD(data, self.Value2)

        data = CommFunc.WriteBYTE(data, self.MemberCount)

        for i in range(self.MemberCount):

            data = CommFunc.WriteString(data, self.MemberList[i].GetLength(), self.MemberList[i].GetBuffer())

        data = CommFunc.WriteWORD(data, self.ApplyCount)

        for i in range(self.ApplyCount):

            data = CommFunc.WriteDWORD(data, self.ApplyIDList[i])

        for i in range(self.ApplyCount):

            data = CommFunc.WriteString(data, self.ApplyInfoList[i].GetLength(), self.ApplyInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                TeamID:%d,

                                CreateTime:%d,

                                FuncMapID:%d,

                                FuncMapEx:%d,

                                NameLen:%d,

                                TeamName:%s,

                                CaptainID:%d,

                                MinLV:%d,

                                MinFightPower:%d,

                                MinFightPowerEx:%d,

                                ServerOnly:%d,

                                NeedCheck:%d,

                                Value1:%d,

                                Value2:%d,

                                MemberCount:%d,

                                MemberList:%s,

                                ApplyCount:%d,

                                ApplyIDList:%s,

                                ApplyInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.TeamID,

                                self.CreateTime,

                                self.FuncMapID,

                                self.FuncMapEx,

                                self.NameLen,

                                self.TeamName,

                                self.CaptainID,

                                self.MinLV,

                                self.MinFightPower,

                                self.MinFightPowerEx,

                                self.ServerOnly,

                                self.NeedCheck,

                                self.Value1,

                                self.Value2,

                                self.MemberCount,

                                "...",

                                self.ApplyCount,

                                "...",

                                "..."

                                )

        return DumpString





m_NAtagMCFuncTeamRefresh=tagMCFuncTeamRefresh()

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





#------------------------------------------------------

# B9 21 查找玩家功能队伍结果 #tagMCQueryPlayerFuncTeamRet



class  tagMCQueryPlayerFuncTeamRet(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("FuncMapID", c_int),    # 功能地图ID或自定义的活动功能ID

                  ("TeamID", c_int),    # 玩家所属队伍ID，目前只同步0的情况，如果玩家有队伍统一B920封包同步处理

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xB9

        self.SubCmd = 0x21

        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 = 0xB9

        self.SubCmd = 0x21

        self.FuncMapID = 0

        self.TeamID = 0

        return



    def GetLength(self):

        return sizeof(tagMCQueryPlayerFuncTeamRet)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// B9 21 查找玩家功能队伍结果 //tagMCQueryPlayerFuncTeamRet:

                                Cmd:%s,

                                SubCmd:%s,

                                FuncMapID:%d,

                                TeamID:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.FuncMapID,

                                self.TeamID

                                )

        return DumpString





m_NAtagMCQueryPlayerFuncTeamRet=tagMCQueryPlayerFuncTeamRet()

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





#------------------------------------------------------

# C1 09 跨服排位玩家信息 #tagMCChampionshipPlayerInfo



class  tagMCChampionshipPlayerInfo(Structure):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/DB/DBDataMgr.py

@@ -24,6 +24,7 @@
import DBPlayerViewCache

import DBEventTrig

import DBBillboard

import DBFuncTeam

import DBGameRec

import DBFamily

import DBMail

@@ -220,6 +221,7 @@
        self.MailMgr = DBMail.MailMgr()

        self.FamilyMgr = DBFamily.FamilyMgr()

        self.GameRecMgr = DBGameRec.GameRecMgr()

        self.FuncTeamMgr = DBFuncTeam.FuncTeamMgr()

        return

    

    def GetSaveData(self):

@@ -230,6 +232,7 @@
        buff += self.MailMgr.GetSaveData()

        buff += self.FamilyMgr.GetSaveData()

        buff += self.GameRecMgr.GetSaveData()

        buff += self.FuncTeamMgr.GetSaveData()

        return buff

    

    def LoadGameData(self, gameBuffer, pos):

@@ -240,6 +243,7 @@
        pos = self.MailMgr.LoadPyGameData(gameBuffer, pos, dataslen)

        pos = self.FamilyMgr.LoadPyGameData(gameBuffer, pos, dataslen)

        pos = self.GameRecMgr.LoadPyGameData(gameBuffer, pos, dataslen)

        pos = self.FuncTeamMgr.LoadPyGameData(gameBuffer, pos, dataslen)

        return pos

    

def GetDBDataMgr():

@@ -284,3 +288,7 @@
    dbDataMgr = GetDBDataMgr()

    return dbDataMgr.GameRecMgr



def GetFuncTeamMgr():

    ## 功能队伍数据管理器

    dbDataMgr = GetDBDataMgr()

    return dbDataMgr.FuncTeamMgr


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/DB/DBStruct.py

@@ -2029,11 +2029,259 @@
        return output





# 功能队伍表 #tagDBFuncTeam

class tagDBFuncTeam(Structure):

    _pack_ = 1

    _fields_ = [

        ('TeamID', ctypes.c_ulong),

        ('TeamName', ctypes.c_char * 33),

        ('ZoneID', ctypes.c_ubyte),

        ('FuncMapID', ctypes.c_ulong),

        ('FuncMapEx', ctypes.c_ulong),

        ('CreateTime', ctypes.c_ulong),

        ('CaptainID', ctypes.c_ulong),

        ('MinLV', ctypes.c_ushort),

        ('MinFightPower', ctypes.c_ulong),

        ('MinFightPowerEx', ctypes.c_ulong),

        ('ServerOnly', ctypes.c_ubyte),

        ('NeedCheck', ctypes.c_ubyte),

        ('ApplyIDLen', ctypes.c_ushort),

        ('ApplyIDList', ctypes.c_char_p),

        ('Value1', ctypes.c_ulong),

        ('Value2', ctypes.c_ulong),

        ('Value3', ctypes.c_ulong),

        ('Value4', ctypes.c_ulong),

        ('Value5', ctypes.c_ulong),

        ('ADOResult', ctypes.c_ulong),

    ]



    def __init__(self):

        Structure.__init__(self)

        self.clear()



    def clear(self):

        self.TeamID = 0

        self.TeamName = ''

        self.ZoneID = 0

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.CreateTime = 0

        self.CaptainID = 0

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        self.ApplyIDLen = 0

        self.ApplyIDList = ''

        self.Value1 = 0

        self.Value2 = 0

        self.Value3 = 0

        self.Value4 = 0

        self.Value5 = 0



    def readData(self, buf, pos = 0, length = 0):

        if not pos <= length:

            return -1

        if len(buf) < pos + self.getLength():

            return -1

        self.clear()

        self.TeamID, pos = CommFunc.ReadDWORD(buf, pos)

        self.TeamName, pos = CommFunc.ReadString(buf, pos, 33)

        self.ZoneID, pos = CommFunc.ReadBYTE(buf, pos)

        self.FuncMapID, pos = CommFunc.ReadDWORD(buf, pos)

        self.FuncMapEx, pos = CommFunc.ReadDWORD(buf, pos)

        self.CreateTime, pos = CommFunc.ReadDWORD(buf, pos)

        self.CaptainID, pos = CommFunc.ReadDWORD(buf, pos)

        self.MinLV, pos = CommFunc.ReadWORD(buf, pos)

        self.MinFightPower, pos = CommFunc.ReadDWORD(buf, pos)

        self.MinFightPowerEx, pos = CommFunc.ReadDWORD(buf, pos)

        self.ServerOnly, pos = CommFunc.ReadBYTE(buf, pos)

        self.NeedCheck, pos = CommFunc.ReadBYTE(buf, pos)

        self.ApplyIDLen, pos = CommFunc.ReadWORD(buf, pos)

        tmp, pos = CommFunc.ReadString(buf, pos, self.ApplyIDLen)

        self.ApplyIDList = ctypes.c_char_p(tmp)

        self.Value1, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value2, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value3, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value4, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value5, pos = CommFunc.ReadDWORD(buf, pos)

        return self.getLength()



    def getBuffer(self):

        buf = ''

        buf = CommFunc.WriteDWORD(buf, self.TeamID)

        buf = CommFunc.WriteString(buf, sizeof(ctypes.c_char) * 33, self.TeamName)

        buf = CommFunc.WriteBYTE(buf, self.ZoneID)

        buf = CommFunc.WriteDWORD(buf, self.FuncMapID)

        buf = CommFunc.WriteDWORD(buf, self.FuncMapEx)

        buf = CommFunc.WriteDWORD(buf, self.CreateTime)

        buf = CommFunc.WriteDWORD(buf, self.CaptainID)

        buf = CommFunc.WriteWORD(buf, self.MinLV)

        buf = CommFunc.WriteDWORD(buf, self.MinFightPower)

        buf = CommFunc.WriteDWORD(buf, self.MinFightPowerEx)

        buf = CommFunc.WriteBYTE(buf, self.ServerOnly)

        buf = CommFunc.WriteBYTE(buf, self.NeedCheck)

        buf = CommFunc.WriteWORD(buf, self.ApplyIDLen)

        buf = CommFunc.WriteString(buf, self.ApplyIDLen, self.ApplyIDList)

        buf = CommFunc.WriteDWORD(buf, self.Value1)

        buf = CommFunc.WriteDWORD(buf, self.Value2)

        buf = CommFunc.WriteDWORD(buf, self.Value3)

        buf = CommFunc.WriteDWORD(buf, self.Value4)

        buf = CommFunc.WriteDWORD(buf, self.Value5)

        return buf



    def getLength(self):

        length = 0

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_char) * 33

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ushort)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ushort)

        length += self.ApplyIDLen

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        return length



    def outputString(self):

        output = '''// 功能队伍表 #tagDBFuncTeam:

            TeamID = %s,

            TeamName = %s,

            ZoneID = %s,

            FuncMapID = %s,

            FuncMapEx = %s,

            CreateTime = %s,

            CaptainID = %s,

            MinLV = %s,

            MinFightPower = %s,

            MinFightPowerEx = %s,

            ServerOnly = %s,

            NeedCheck = %s,

            ApplyIDLen = %s,

            ApplyIDList = %s,

            Value1 = %s,

            Value2 = %s,

            Value3 = %s,

            Value4 = %s,

            Value5 = %s,

            ADOResult = %s,

            '''%(

                self.TeamID,

                self.TeamName,

                self.ZoneID,

                self.FuncMapID,

                self.FuncMapEx,

                self.CreateTime,

                self.CaptainID,

                self.MinLV,

                self.MinFightPower,

                self.MinFightPowerEx,

                self.ServerOnly,

                self.NeedCheck,

                self.ApplyIDLen,

                self.ApplyIDList,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

                self.ADOResult,

            )

        return output



    #Char数组类型Set接口,使用该接口对此类型数据赋值，防止赋值的数据过长报错

    def SetTeamName(self,Str):

        if len(Str)<=33:

            self.TeamName = Str

        else:

            self.TeamName = Str[:33]

            


# 功能队伍成员表 #tagDBFuncTeamMem

class tagDBFuncTeamMem(Structure):

    _pack_ = 1

    _fields_ = [

        ('TeamID', ctypes.c_ulong),

        ('PlayerID', ctypes.c_ulong),

        ('Value1', ctypes.c_ulong),

        ('Value2', ctypes.c_ulong),

        ('Value3', ctypes.c_ulong),

        ('Value4', ctypes.c_ulong),

        ('Value5', ctypes.c_ulong),

        ('ADOResult', ctypes.c_ulong),

    ]



    def __init__(self):

        Structure.__init__(self)

        self.clear()





    def clear(self):

        memset(addressof(self), 0, self.getLength())



    def readData(self, buf, pos = 0, length = 0):

        if not pos <= length:

            return -1

        if len(buf) < pos + self.getLength():

            return -1

        self.clear()

        self.TeamID, pos = CommFunc.ReadDWORD(buf, pos)

        self.PlayerID, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value1, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value2, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value3, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value4, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value5, pos = CommFunc.ReadDWORD(buf, pos)

        return self.getLength()





    def getBuffer(self):

        buf = create_string_buffer(self.getLength())

        memmove(addressof(buf), addressof(self), self.getLength())

        return string_at(addressof(buf), self.getLength())



    def getLength(self):

        return sizeof(tagDBFuncTeamMem)



    def outputString(self):

        output = '''// 功能队伍成员表 #tagDBFuncTeamMem:

            TeamID = %s,

            PlayerID = %s,

            Value1 = %s,

            Value2 = %s,

            Value3 = %s,

            Value4 = %s,

            Value5 = %s,

            ADOResult = %s,

            '''%(

                self.TeamID,

                self.PlayerID,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

                self.ADOResult,

            )

        return output







#服务器世界数据表版本号

GAMEWORLD_DATA_VERSION_NO = ctypes.c_ulong (\

    sizeof(tagDBEventTrig) + sizeof(tagDBFamily) + sizeof(tagDBFamilyMem) + sizeof(tagDBFamilyAction) + 

    sizeof(tagDBPlayerViewCache) + sizeof(tagDBMailPersonal) + sizeof(tagDBMailServer) + sizeof(tagDBMailItem) + 

    sizeof(tagDBMailPlayerRec) + sizeof(tagDBBillboard) + sizeof(tagDBGameRec)

    sizeof(tagDBMailPlayerRec) + sizeof(tagDBBillboard) + sizeof(tagDBGameRec) + sizeof(tagDBFuncTeam) + sizeof(tagDBFuncTeamMem)

    ).value

    

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/DB/StructData/DBFamily.py

@@ -366,7 +366,7 @@
                continue

            familyFightPowerTotal += member.GetFightPowerTotal()

        self.SetFightPowerTotal(familyFightPowerTotal)

        GameWorld.DebugLog("刷新仙盟总战力! familyID=%s" % self.GetID())

        #GameWorld.DebugLog("刷新仙盟总战力! familyID=%s" % self.GetID())

        self.__memFightPowerChange = False

        return familyFightPowerTotal

    


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/DB/StructData/DBFuncTeam.py

New file
@@ -0,0 +1,397 @@
#!/usr/bin/python

# -*- coding: GBK -*-

#-------------------------------------------------------------------------------

#

##@package DB.StructData.DBFuncTeam

#

# @todo:功能队伍表

# @author hxp

# @date 2025-05-28

# @version 1.0

#

# 详细描述: 功能队伍表

#

#-------------------------------------------------------------------------------

#"""Version = 2025-05-28 10:00"""

#-------------------------------------------------------------------------------



import DBStruct

import GameWorld

import IpyGameDataPY

import PlayerViewCache

import DBDataMgr

import CommFunc

import ChConfig



import time



class FuncTeamMem():

    ## 功能队伍成员

    
    def __init__(self, dbData=None):

        self.__dbData = DBStruct.tagDBFuncTeamMem() if not dbData else dbData

        return

    
    def GetTeamID(self): return self.__dbData.TeamID

    def SetTeamID(self, teamID): self.__dbData.TeamID = teamID

    def GetPlayerID(self): return self.__dbData.PlayerID

    def SetPlayerID(self, playerID): self.__dbData.PlayerID = playerID

    def GetValue1(self): return self.__dbData.Value1

    def SetValue1(self, value1): self.__dbData.Value1 = value1

    def GetValue2(self): return self.__dbData.Value2

    def SetValue2(self, value2): self.__dbData.Value2 = value2

    def GetValue3(self): return self.__dbData.Value3

    def SetValue3(self, value3): self.__dbData.Value3 = value3

    def GetValue4(self): return self.__dbData.Value4

    def SetValue4(self, value4): self.__dbData.Value4 = value4

    def GetValue5(self): return self.__dbData.Value5

    def SetValue5(self, value5): self.__dbData.Value5 = value5

    def GetBuffer(self): return self.__dbData.getBuffer()

    
    def GetFightPower(self):

        viewCache = PlayerViewCache.FindViewCache(self.GetPlayerID())

        return viewCache.GetFightPowerTotal() if viewCache else 0

    
class FuncTeam():

    ## 功能队伍

    
    def __init__(self, dbData=None):

        self.__dbData = DBStruct.tagDBFuncTeam() if not dbData else dbData

        self.__memberList = []

        try:

            self.__applyIDList = eval(self.__dbData.ApplyIDList)

        except:

            self.__applyIDList = []  
        return

    
    def GetTeamID(self): return self.__dbData.TeamID

    def SetTeamID(self, teamID): self.__dbData.TeamID = teamID

    def GetTeamName(self): return self.__dbData.TeamName

    def SetTeamName(self, teamName): self.__dbData.SetTeamName(teamName)

    def GetZoneID(self): return self.__dbData.ZoneID

    def SetZoneID(self, zoneID): self.__dbData.ZoneID = zoneID

    def GetFuncMapID(self): return self.__dbData.FuncMapID

    def SetFuncMapID(self, funcMapID): self.__dbData.FuncMapID = funcMapID

    def GetFuncMapEx(self): return self.__dbData.FuncMapEx

    def SetFuncMapEx(self, funcMapEx): self.__dbData.FuncMapEx = funcMapEx

    def GetCreateTime(self): return self.__dbData.CreateTime

    def SetCreateTime(self, createTime): self.__dbData.CreateTime = createTime

    def GetCaptainID(self): return self.__dbData.CaptainID

    def SetCaptainID(self, captainID): self.__dbData.CaptainID = captainID

    def GetMinLV(self): return self.__dbData.MinLV

    def SetMinLV(self, minLV): self.__dbData.MinLV = minLV

    def GetMinFightPower(self): return self.__dbData.MinFightPower

    def GetMinFightPowerEx(self): return self.__dbData.MinFightPowerEx

    def SetMinFightPowerTotal(self, minFightPower):

        self.__dbData.MinFightPower = minFightPower % ChConfig.Def_PerPointValue

        self.__dbData.MinFightPowerEx = minFightPower / ChConfig.Def_PerPointValue

        return

    def GetServerOnly(self): return self.__dbData.ServerOnly

    def SetServerOnly(self, serverOnly): self.__dbData.ServerOnly = serverOnly

    def GetNeedCheck(self): return self.__dbData.NeedCheck

    def SetNeedCheck(self, needCheck): self.__dbData.NeedCheck = needCheck

    def GetValue1(self): return self.__dbData.Value1

    def SetValue1(self, value1): self.__dbData.Value1 = value1

    def GetValue2(self): return self.__dbData.Value2

    def SetValue2(self, value2): self.__dbData.Value2 = value2

    def GetValue3(self): return self.__dbData.Value3

    def SetValue3(self, value3): self.__dbData.Value3 = value3

    def GetValue4(self): return self.__dbData.Value4

    def SetValue4(self, value4): self.__dbData.Value4 = value4

    def GetValue5(self): return self.__dbData.Value5

    def SetValue5(self, value5): self.__dbData.Value5 = value5

    def GetBuffer(self):

        self.__dbData.ApplyIDList = str(self.__applyIDList).replace(" ", "")

        self.__dbData.ApplyIDLen = len(self.__dbData.ApplyIDList)

        return self.__dbData.getBuffer()

    
    def InitTeamMemInstance(self, dbData):

        '''初始化功能数据实例，创建或加载数据时通用，功能一般不调用

        @param dbData: 实例对应绑定的dbData

        @return: 成功返回实例对象，失败返回None

        '''

        
        teamMem = FuncTeamMem(dbData)

        self.__memberList.append(teamMem)

        
        DBDataMgr.GetFuncTeamMgr().UpdPlayerTeamID(teamMem.GetPlayerID(), self.GetFuncMapID(), self.GetTeamID())

        return teamMem

    
    def AddTeamMember(self, playerID):

        teamMem = None

        self.DelApplyID(playerID) # 加入的同时从申请列表中移除

        mem = self.GetMemberByID(playerID)

        if mem:

            teamMem = mem

            return teamMem

        
        dbData = DBStruct.tagDBFuncTeamMem()

        dbData.TeamID = self.GetTeamID()

        dbData.PlayerID = playerID

        
        teamMem = self.InitTeamMemInstance(dbData)

        return teamMem

    
    def GetMemberCount(self): return len(self.__memberList)

    def GetMemberAt(self, index):

        mem = None

        if 0 <= index < len(self.__memberList):

            mem = self.__memberList[index]

        elif False:

            mem = FuncTeamMem()

        return mem

    def GetMemberIDList(self): return [mem.GetPlayerID() for mem in self.__memberList]

    def GetMemberByID(self, playerID):

        for mem in self.__memberList:

            if mem.GetPlayerID() == playerID:

                return mem

        return

    
    def GetMemFightPowerTotal(self):

        ## 队员总战力

        totalFightPower = 0

        for mem in self.__memberList:

            totalFightPower += mem.GetFightPower()

        return totalFightPower

    
    def DelTeamMember(self, playerID):

        for mem in self.__memberList[::-1]:

            if mem.GetPlayerID() == playerID:

                self.__memberList.remove(mem)

                
                DBDataMgr.GetFuncTeamMgr().UpdPlayerTeamID(playerID, self.GetFuncMapID(), 0)

                break

        return

    
    def GetApplyIDList(self): return self.__applyIDList

    
    def AddApplyID(self, playerID):

        if playerID not in self.__applyIDList:

            self.__applyIDList.append(playerID)

        return

    
    def DelApplyID(self, playerID):

        if playerID in self.__applyIDList:

            self.__applyIDList.remove(playerID)

        return

    
    def DelApplyIDAll(self):

        self.__applyIDList = []

        return

    
class FuncTeamMgr():

    ## 功能队伍管理

    
    def __init__(self):

        self.__funcTeamDict = {} # {teamID:FuncTeam, ...}

        self.__funcTeamListDict = {} # {funcMapID:{zoneID:[FuncTeam, ...], ...}, ...}

        self.__playerFuncTeamIDDict = {} # {playerID:{funcMapID:teamID, ...}, ...} # 
        self.__loopTeamID = 0 # 递增，直到超过上限后，再从头开始

        return

    
    def __GetNewTeamID(self):

        ## 获取新队伍ID

        idMin, idMax = 100, 9999 # 非跨服队伍ID范围，存储本服，合服清空

        if GameWorld.IsCrossServer():

            idMin, idMax = 10000, 99999 # 跨服队伍ID范围，存储跨服，合服不影响

            
        teamMax = idMax - idMin + 1

        if len(self.__funcTeamDict) >= teamMax:

            GameWorld.ErrLog("功能队伍ID已满!")

            return

        
        if not self.__loopTeamID and self.__funcTeamDict:

            self.__loopTeamID = max(self.__funcTeamDict)

            
        newTeamID = 0

        doCount = 0

        while doCount < teamMax:

            doCount += 1

            if not self.__loopTeamID or self.__loopTeamID >= idMax or self.__loopTeamID < idMin:

                self.__loopTeamID = idMin

            else:

                self.__loopTeamID += 1

            if self.__loopTeamID not in self.__funcTeamDict:

                newTeamID = self.__loopTeamID

                break

        return newTeamID

    
    def __InitTeamInstance(self, dbData):

        '''初始化功能数据实例，创建或加载数据时通用，功能一般不调用

        @param dbData: 实例对应绑定的dbData

        @return: 成功返回实例对象，失败返回None

        '''

        team = FuncTeam(dbData)

        teamID = team.GetTeamID()

        zoneID = team.GetZoneID()

        funcMapID = team.GetFuncMapID()

        funcTeamList = self.__getFuncTeamList(funcMapID, zoneID)

        if team not in funcTeamList:

            funcTeamList.append(team)

            
        self.__funcTeamDict[teamID] = team

        return team

    
    def __getFuncTeamList(self, funcMapID, zoneID):

        if funcMapID not in self.__funcTeamListDict:

            self.__funcTeamListDict[funcMapID] = {}

        funcZoneTeamDict = self.__funcTeamListDict[funcMapID]

        if zoneID not in funcZoneTeamDict:

            funcZoneTeamDict[zoneID] = []

        funcTeamList = funcZoneTeamDict[zoneID]

        return funcTeamList

    
    def CreateFuncTeam(self, playerID, funcMapID, funcMapEx, teamName="", zoneID=0):

        funcTeam = None

        teamID = self.__GetNewTeamID()

        if not teamID:

            return funcTeam

        
        dbData = DBStruct.tagDBFuncTeam()

        dbData.TeamID = teamID

        dbData.TeamName = teamName

        dbData.ZoneID = zoneID

        dbData.FuncMapID = funcMapID

        dbData.FuncMapEx = funcMapEx

        dbData.CreateTime = int(time.time())

        dbData.CaptainID = playerID

        
        funcTeam = self.__InitTeamInstance(dbData)

        funcTeam.AddTeamMember(playerID)

        return funcTeam

    
    def SortTeam(self, funcMapID, zoneID, sortReason=""):

        ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

        if not ipyData:

            return

        sortType = ipyData.GetSortType()

        sortReverse = ipyData.GetSortReverse()

        
        teamList = self.__getFuncTeamList(funcMapID, zoneID)

        if not teamList:

            return

        
        # 按创建时间

        if sortType == 0:

            if not sortReason or sortReason == "create":

                teamList.sort(key=lambda t: (t.GetCreateTime()), reverse=sortReverse)

                #GameWorld.DebugLog("按时间排序: zoneID=%s,funcMapID=%s,sortReason=%s" % (zoneID, funcMapID, sortReason))

        # 按队员总战力

        elif sortType == 1:

            if not sortReason or sortReason == "member":

                teamList.sort(key=lambda t: (t.GetMemFightPowerTotal()), reverse=sortReverse)

                #GameWorld.DebugLog("按战力排序: zoneID=%s,funcMapID=%s,sortReason=%s" % (zoneID, funcMapID, sortReason))

        return

    
    def GetFuncTeam(self, teamID):

        funcTeam = None

        if teamID in self.__funcTeamDict:

            funcTeam = self.__funcTeamDict[teamID]

        if not funcTeam and False:

            # 不会执行，仅为了.提示代码用

            funcTeam = FuncTeam()

        return funcTeam

    
    def DelTeam(self, teamID):

        ## 删除队伍

        funcTeam = self.GetFuncTeam(teamID)

        if not funcTeam:

            return

        
        zoneID = funcTeam.GetZoneID()

        funcMapID = funcTeam.GetFuncMapID()

        for index in range(funcTeam.GetMemberCount()):

            mem = funcTeam.GetMemberAt(index)

            self.UpdPlayerTeamID(mem.GetPlayerID(), funcMapID, 0)

            
        # 移除实例

        teamList = self.__getFuncTeamList(funcMapID, zoneID)

        if funcTeam in teamList:

            teamList.remove(funcTeam)

                        
        self.__funcTeamDict.pop(teamID, None)

        return

    
    def UpdPlayerTeamID(self, playerID, funcMapID, teamID):

        if playerID not in self.__playerFuncTeamIDDict:

            self.__playerFuncTeamIDDict[playerID] = {}

        teamIDDict = self.__playerFuncTeamIDDict[playerID]

        if not teamID:

            teamIDDict.pop(funcMapID, 0)

            if not teamIDDict:

                self.__playerFuncTeamIDDict.pop(playerID, None)

        else:

            teamIDDict[funcMapID] = teamID

        return

    
    def GetPlayerTeamID(self, playerID, funcMapID):

        if playerID not in self.__playerFuncTeamIDDict:

            return 0

        teamIDDict = self.__playerFuncTeamIDDict[playerID]

        return teamIDDict.get(funcMapID, 0)

    #def GetPlayerTeamIDDict(self, playerID): return self.playerFuncTeamIDDict.get(playerID, {})

    
    def IsTeamPlayer(self, playerID):

        if playerID in self.__playerFuncTeamIDDict:

            return True

        for zoneTeamInfo in self.__funcTeamListDict.values():

            for funcTeamList in zoneTeamInfo.values():

                for funcTeam in funcTeamList:

                    if playerID in funcTeam.GetApplyIDList():

                        return True

        return False

    
    # 保存数据 存数据库和realtimebackup

    def GetSaveData(self):

        
        teamCnt, teamSavaData = 0, ""

        memCnt, memSavaData = 0, ""

        for zoneTeamInfo in self.__funcTeamListDict.values():

            for funcTeamList in zoneTeamInfo.values():

                for funcTeam in funcTeamList:

                    teamSavaData += funcTeam.GetBuffer()

                    teamCnt += 1

                    for index in range(funcTeam.GetMemberCount()):

                        mem = funcTeam.GetMemberAt(index)

                        memSavaData += mem.GetBuffer()

                        memCnt += 1

                    
        saveData = ""

        
        saveData += CommFunc.WriteDWORD("", teamCnt) + teamSavaData

        GameWorld.Log("Save DBFuncTeam count :%s len=%s" % (teamCnt, len(teamSavaData)))

        
        saveData += CommFunc.WriteDWORD("", memCnt) + memSavaData

        GameWorld.Log("Save DBFuncTeamMem count :%s len=%s" % (memCnt, len(memSavaData)))

        
        return saveData

    
    # 从数据库载入数据

    def LoadPyGameData(self, datas, pos, dataslen):

        
        # 队伍

        cnt, pos = CommFunc.ReadDWORD(datas, pos)

        GameWorld.Log("Load DBFuncTeam count :%s" % cnt)

        for _ in xrange(cnt):

            dbData = DBStruct.tagDBFuncTeam()

            pos += dbData.readData(datas, pos, dataslen)

            self.__InitTeamInstance(dbData)

            
        # 成员

        cnt, pos = CommFunc.ReadDWORD(datas, pos)

        GameWorld.Log("Load DBFuncTeamMem count :%s" % cnt)

        for _ in xrange(cnt):

            dbData = DBStruct.tagDBFuncTeamMem()

            pos += dbData.readData(datas, pos, dataslen)

            
            team = self.GetFuncTeam(dbData.TeamID)

            if not team:

                continue

            team.InitTeamMemInstance(dbData)

            
        # 排序

        for funcMapID, zoneTeamInfo in self.__funcTeamListDict.items():

            for zoneID in zoneTeamInfo.keys():

                self.SortTeam(funcMapID, zoneID)

        return pos

    

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/DB/StructData/DBGameRec.py

@@ -364,7 +364,7 @@
        

        for _ in xrange(cnt):

            dbData = DBStruct.tagDBGameRec()

            dbData.readData(datas, pos, dataslen)

            pos += dbData.readData(datas, pos, dataslen)

            recType = dbData.RecType

            recID = dbData.RecID

            recTypeIDMgr = self.GetRecTypeIDMgr(recType, recID)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/GameWorldLogic/FBProcess/GameLogic_CrossBattlefield.py

@@ -25,11 +25,11 @@
import GameWorldProcess

import NPCCustomRefresh

import DataRecordPack

import PlayerFuncTeam

import PlayerControl

import ShareDefine

import SkillCommon

import SkillShell

import DBDataMgr

import BuffSkill

import ChConfig

import AICommon

@@ -898,9 +898,10 @@
        faction = callFaction # 召集阵营为固定阵营

        

    # 队伍同阵营

    teamID = PlayerFuncTeam.GetPlayerTeamID(playerID, ChConfig.Def_FBMapID_CrossBattlefield)

    if not faction and teamID:

        memIDList = PlayerFuncTeam.GetMemberIDList(teamID)

    teamID = DBDataMgr.GetFuncTeamMgr().GetPlayerTeamID(playerID, ChConfig.Def_FBMapID_CrossBattlefield)

    funcTeam = DBDataMgr.GetFuncTeamMgr().GetFuncTeam(teamID)

    if not faction and teamID and funcTeam:

        memIDList = funcTeam.GetMemberIDList()

        for memID in memIDList:

            memBattleObj = GetBattlePlayerObj(memID)

            if memBattleObj.faction:

@@ -1780,7 +1781,7 @@
            

            isCallOpen = 1 if playerID in worldObj.callOpenPlayerInfo else 0 # 是否召集进入的

            isCalled = 1 if (playerID in allCallPlayerIDList and not isCallOpen) else 0 # 是否被召集的

            teamID = PlayerFuncTeam.GetPlayerTeamID(playerID, ChConfig.Def_FBMapID_CrossBattlefield)

            teamID = DBDataMgr.GetFuncTeamMgr().GetPlayerTeamID(playerID, ChConfig.Def_FBMapID_CrossBattlefield)

            killCnt, ckillCntInfo, killBossCnt, killScoreKing, killGuardCnt, auraScore, superItemAwardCnt, \

                factionBuffCollCnt, personBuffCollCnt, crystalCollCnt, wallCollCnt = \

                battleObj.killCount, battleObj.ckillCntInfo, battleObj.killBossCnt, battleObj.killScoreKing, battleObj.killGuardCnt, \


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/IpyGameDataPY.py

@@ -45,6 +45,17 @@
                        ("char", "Word", 0),

                        ),



                "FuncTeamSet":(

                        ("DWORD", "FuncMapID", 1),

                        ("BYTE", "NeedName", 0),

                        ("BYTE", "MemberMax", 0),

                        ("BYTE", "ApplyMax", 0),

                        ("BYTE", "ReqApplyMax", 0),

                        ("BYTE", "SortType", 0),

                        ("BYTE", "SortReverse", 0),

                        ("BYTE", "OPLimitInAct", 0),

                        ),



                "Dienstgrad":(

                        ("DWORD", "ID", 1),

                        ("WORD", "Type", 0),

@@ -2650,6 +2661,22 @@
        
    def GetID(self): return self.attrTuple[0] # WORD

    def GetWord(self): return self.attrTuple[1] # 屏蔽词 char

# 功能队伍设定表
class IPY_FuncTeamSet():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetFuncMapID(self): return self.attrTuple[0] # 功能地图ID DWORD

    def GetNeedName(self): return self.attrTuple[1] # 需要队伍名 BYTE

    def GetMemberMax(self): return self.attrTuple[2] # 最大人员数 BYTE

    def GetApplyMax(self): return self.attrTuple[3] # 最大接受申请数 BYTE

    def GetReqApplyMax(self): return self.attrTuple[4] # 最大申请数 BYTE

    def GetSortType(self): return self.attrTuple[5] # 队伍列表排序方案 BYTE

    def GetSortReverse(self): return self.attrTuple[6] # 是否倒序 BYTE

    def GetOPLimitInAct(self): return self.attrTuple[7] # 活动期间限制队伍操作 BYTE

# 称号表
class IPY_Dienstgrad():
@@ -6637,6 +6664,7 @@
            self.ipyConfigEx = {}

        self.__LoadFileData("DirtyList", onlyCheck)

        self.__LoadFileData("DirtyName", onlyCheck)

        self.__LoadFileData("FuncTeamSet", onlyCheck)

        self.__LoadFileData("Dienstgrad", onlyCheck)

        self.__LoadFileData("TitleStarUp", onlyCheck)

        self.__LoadFileData("PlayerFace", onlyCheck)

@@ -7131,6 +7159,13 @@
        self.CheckLoadData("DirtyName")
        return self.ipyDirtyNameCache[index]


    def GetFuncTeamSetCount(self):
        self.CheckLoadData("FuncTeamSet")
        return self.ipyFuncTeamSetLen

    def GetFuncTeamSetByIndex(self, index):
        self.CheckLoadData("FuncTeamSet")
        return self.ipyFuncTeamSetCache[index]


    def GetDienstgradCount(self):
        self.CheckLoadData("Dienstgrad")
        return self.ipyDienstgradLen


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerEventCounter.py

@@ -126,7 +126,6 @@
import PyGameData

import PlayerGuaji

import PlayerXiangong

import PlayerFuncTeam

import PlayerMineArea

import PlayerBillboard

import PlayerViewCache

@@ -1237,11 +1236,6 @@
        if key == ShareDefine.Def_Notify_WorldKey_LuckyCloudBuyInfo:

            PyGameData.g_luckyCloudBuyInfo = eval(msgValue)

            PlayerLuckyCloudBuy.OnLuckyCloudBuyChange()

            return

        
        # 功能队伍

        if key == ShareDefine.Def_Notify_WorldKey_FuncTeamMemIDInfo:

            PlayerFuncTeam.OnFuncTeamMemIDRefresh(eval(msgValue))

            return

        

        if key == ShareDefine.Def_Notify_WorldKey_CrossBattlefieldCallTeamInfo:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerFamilyZhenbaoge.py

@@ -100,7 +100,7 @@
    SetFAItemList(gActionData, itemList)

    

    PlayerFamily.SendFamilyAction(gActionData)

    GameWorld.DebugLog("珍宝阁重置! familyID=%s,itemList=%s" % (familyID, itemList), familyID)    
    #GameWorld.DebugLog("珍宝阁重置! familyID=%s,itemList=%s" % (familyID, itemList), familyID)    
    return



def GetZhenbaogeActionData(familyID, playerID):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerFuncTeam.py

@@ -6,51 +6,1081 @@
#

# @todo:功能队伍表

# @author hxp

# @date 2024-08-02

# @date 2025-05-28

# @version 1.0

#

# 详细描述: 功能队伍表

# 详细描述: 功能队伍表，支持跨服

#

#-------------------------------------------------------------------------------

#"""Version = 2024-08-02 16:30"""

#"""Version = 2025-05-28 10:00"""

#-------------------------------------------------------------------------------



import PyGameData

import GameWorld

import ShareDefine

import IpyGameDataPY

#import CrossBattlefield

import CrossRealmPlayer

import PlayerViewCache

import ChPyNetSendPack

#import CrossRealmMsg

import PlayerControl

import NetPackCommon

import DBDataMgr

import DirtyList

import ChConfig



def OnFuncTeamMemIDRefresh(msgList):

    ## 功能队伍成员ID刷新

    teamIDList, delTeamIDList, teamMemIDInfoDict = msgList

# 队伍操作

Def_FuncTeamOPList = (

Def_FuncTeamOP_JoinApply, # 申请加入 1

Def_FuncTeamOP_JoinCancel, # 申请取消 2

Def_FuncTeamOP_JoinAgree, # 同意入队 3

Def_FuncTeamOP_JoinRefuse, # 拒绝入队 4

Def_FuncTeamOP_Exit, # 退出队伍 5

Def_FuncTeamOP_Kick, # 踢出队伍 6

Def_FuncTeamOP_Transfer, # 转让队长 7

Def_FuncTeamOP_Dissolve, # 解散队伍 8

) = range(1, 1 + 8)

    

    # 没有指定时，全部刷新

    if not teamIDList:

        PyGameData.g_funcTeamPlayerDict = {}

def IsOPLimitInAct(curPlayer, funcMapID):

    ## 活动期间是否限制队伍操作

    ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

    if not ipyData:

        return

    if not ipyData.GetOPLimitInAct():

        return

    isInAct = False

    if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:

        isInAct = CrossBattlefield.GetCrossBattlefieldState()

    if isInAct:

        GameWorld.ErrLog("活动期间无法操作队伍! funcMapID=%s" % funcMapID, curPlayer.GetPlayerID())

    return isInAct

        

    for key, refreshDict in teamMemIDInfoDict.items():

        if key not in PyGameData.g_funcTeamPlayerDict:

            PyGameData.g_funcTeamPlayerDict[key] = {}

        infoDict = PyGameData.g_funcTeamPlayerDict[key]

        infoDict.update(refreshDict)

def GetFuncTeamZoneID(funcMapID):

    zoneID = 0

    if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:

        zoneID = CrossBattlefield.GetCrossBattlefieldZoneID(GameWorld.GetServerGroupID())

    return zoneID

        

    for teamInfoDict in PyGameData.g_funcTeamPlayerDict.values():

        for delTeamID in delTeamIDList[::-1]:

            if delTeamID not in teamInfoDict:

                continue

            teamInfoDict.pop(delTeamID, None)

            delTeamIDList.remove(delTeamID)

#// B9 20 创建功能队伍 #tagCMCreateFuncTeam

#

#struct    tagCMCreateFuncTeam

#{

#    tagHead        Head;

#    DWORD        FuncMapID;    // 功能地图ID或自定义的活动功能ID

#    DWORD        FuncMapEx;    // 功能地图扩展，如不同的层级

#    BYTE        NameLen;

#    char        TeamName[NameLen];    // 队伍名称，可为空

#    WORD        MinLV;        //最低等级限制

#    DWORD        MinFightPower;    //最低战力限制，求余亿

#    DWORD        MinFightPowerEx;    //最低战力限制，整除亿

#    BYTE        ServerOnly;    //是否仅本服玩家可加入，0-否，1-是

#    BYTE        NeedCheck;     //是否需要审核

#};

def OnCreateFuncTeam(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    funcMapID = clientData.FuncMapID

    funcMapEx = clientData.FuncMapEx

    teamName = clientData.TeamName

    minLV = clientData.MinLV

    minFightPower = clientData.MinFightPower

    minFightPowerEx = clientData.MinFightPowerEx

    serverOnly = clientData.ServerOnly

    needCheck = clientData.NeedCheck

            

    if IsOPLimitInAct(curPlayer, funcMapID):

    return



def GetPlayerTeamID(playerID, funcMapID):

    for key, infoDict in PyGameData.g_funcTeamPlayerDict.items():

        if funcMapID != key[1]:

            continue

        for teamID, memIDList in infoDict.items():

            if playerID in memIDList:

                return teamID

    return 0

    zoneID = GetFuncTeamZoneID(funcMapID)

    if not zoneID:

        return



def GetMemberIDList(teamID):

    for infoDict in PyGameData.g_funcTeamPlayerDict.values():

        if teamID in infoDict:

            return infoDict[teamID]

    return []

    teamInfo = {"funcMapID":funcMapID, "funcMapEx":funcMapEx, "teamName":teamName, "minLV":minLV, 
               "minFightPower":minFightPower, "minFightPowerEx":minFightPowerEx, 
               "serverOnly":serverOnly, "needCheck":needCheck}

    dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamInfo":teamInfo, "cacheBase":PlayerViewCache.GetSyncCrossCacheBase(curPlayer)}

    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_CreateFuncTeam, dataMsg)

    return



#// B9 21 修改功能队伍 #tagCMChangeFuncTeam

#

#struct    tagCMChangeFuncTeam

#{

#    tagHead        Head;

#    DWORD        TeamID;

#    DWORD        FuncMapID;    // 功能地图ID或自定义的活动功能ID

#    WORD        MinLV;        //最低等级限制

#    DWORD        MinFightPower;    //最低战力限制，求余亿

#    DWORD        MinFightPowerEx;    //最低战力限制，整除亿

#    BYTE        ServerOnly;    //是否仅本服玩家可加入，0-否，1-是

#    BYTE        NeedCheck;     //是否需要审核

#};

def OnChangeFuncTeam(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    teamID = clientData.TeamID

    funcMapID = clientData.FuncMapID

    minLV = clientData.MinLV

    minFightPower = clientData.MinFightPower

    minFightPowerEx = clientData.MinFightPowerEx

    serverOnly = clientData.ServerOnly

    needCheck = clientData.NeedCheck

    
    if IsOPLimitInAct(curPlayer, funcMapID):

        return

    
    zoneID = GetFuncTeamZoneID(funcMapID)

    if not zoneID:

        return

    
    teamInfo = {"teamID":teamID, "funcMapID":funcMapID, "minLV":minLV, 
               "minFightPower":minFightPower, "minFightPowerEx":minFightPowerEx, 
               "serverOnly":serverOnly, "needCheck":needCheck}

    dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamInfo":teamInfo, "cacheBase":PlayerViewCache.GetSyncCrossCacheBase(curPlayer)}

    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_ChangeFuncTeam, dataMsg)

    return



#// B9 22 功能队伍成员操作 #tagCMFuncTeamMemOP

#

#struct    tagCMFuncTeamMemOP

#{

#    tagHead        Head;

#    DWORD        TeamID;

#    DWORD        FuncMapID;    // 功能地图ID或自定义的活动功能ID

#    BYTE        OPType;        // 1-申请加入；2-申请取消；3-同意入队；4-拒绝入队；5-退出队伍；6-踢出队伍；7-转让队长；8-解散队伍；

#    DWORD        OPData;        // 可选

#};

def OnFuncTeamMemOP(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    teamID = clientData.TeamID

    funcMapID = clientData.FuncMapID

    opType = clientData.OPType

    opData = clientData.OPData

    
    if opType not in Def_FuncTeamOPList:

        return

    
    if IsOPLimitInAct(curPlayer, funcMapID):

        return

    
    zoneID = GetFuncTeamZoneID(funcMapID)

    if not zoneID:

        return

    
    dataMsg = {"zoneID":zoneID, "playerID":playerID, "teamID":teamID, "funcMapID":funcMapID, 
               "opType":opType, "opData":opData}

    dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)

    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_FuncTeamMemOP, dataMsg)

    return



#// B9 23 查找功能队伍列表 #tagCMQueryFuncTeam

#

#struct    tagCMQueryFuncTeam

#{

#    tagHead        Head;

#    DWORD        FuncMapID;    // 功能地图ID或自定义的活动功能ID

#    DWORD        FuncMapEx;    // 功能地图扩展，如不同的层级，0代表所有

#    DWORD        StartIndex;    // 查看的起始索引， 默认0

#    BYTE        QueryCnt;    // 查看条数，默认20，最大不超过100

#    BYTE        HaveSpace;    // 是否只查看有空位置的队伍

#    BYTE        IDLimitType;    // ID限制类型：1-同仙盟队长；2-同ServerGroupID队长；3-同ServerID队长

#    BYTE        SearchLen;

#    char        SearchMsg[SearchLen];    // 指定搜索时有用，可搜索指定队伍ID或模糊搜索队伍名称，搜索时返回最多QueryCnt个数的队伍

#};

def OnQueryFuncTeam(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    funcMapID = clientData.FuncMapID

    funcMapEx = clientData.FuncMapEx

    startIndex = clientData.StartIndex

    queryCnt = clientData.QueryCnt

    haveSpace = clientData.HaveSpace

    idLimitType = clientData.IDLimitType

    searchMsg = clientData.SearchMsg

    
    zoneID = GetFuncTeamZoneID(funcMapID)

    if not zoneID:

        return

    
    dataMsg = {"zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, "funcMapEx":funcMapEx, 
               "startIndex":startIndex, "queryCnt":queryCnt, "haveSpace":haveSpace, "idLimitType":idLimitType, 
               "searchMsg":searchMsg}

    dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)

    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_QueryFuncTeam, dataMsg)

    return



#// B9 24 查找玩家功能队伍 #tagCMQueryPlayerFuncTeam

#

#struct    tagCMQueryPlayerFuncTeam

#{

#    tagHead        Head;

#    DWORD        FuncMapID;    // 功能地图ID或自定义的活动功能ID

#};

def OnQueryPlayerFuncTeam(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    funcMapID = clientData.FuncMapID

    
    zoneID = GetFuncTeamZoneID(funcMapID)

    if not zoneID:

        return

    
    dataMsg = {"zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID}

    dataMsg["cacheBase"] = PlayerViewCache.GetSyncCrossCacheBase(curPlayer)

    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_QueryFuncTeam, dataMsg)

    return



def CrossServerMsg_FuncTeamInfo(msgData):

    ## 子服收到跨服信息 - 队伍刷新信息

    infoType = msgData["infoType"]

    playerID = msgData["playerID"]

    funcMapID = msgData["funcMapID"]

    teamInfo = msgData["teamInfo"]

    teamID = msgData.get("teamID", 0)

    syncPlayerIDList = msgData.get("syncPlayerIDList", [])

    notifyMark = msgData.get("notifyMark", "")

    
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)

    if curPlayer:

        if notifyMark:

            PlayerControl.NotifyCode(curPlayer, notifyMark)

            
    if infoType == "QueryPlayerFuncTeam":

        if curPlayer:

            if teamInfo:

                Sync_FuncTeamRefresh(teamInfo, [playerID])

            else:

                clientPack = ChPyNetSendPack.tagGCQueryPlayerFuncTeamRet()

                clientPack.FuncMapID = funcMapID

                clientPack.TeamID = 0

                NetPackCommon.SendFakePack(curPlayer, clientPack)

        return

    
    if not teamInfo:

        # 操作后没有队伍信息了，解散

        if infoType == "FuncTeamMemOP":

            Sync_FuncTeamDissolve(teamID, syncPlayerIDList)

        return

    
    Sync_FuncTeamRefresh(teamInfo, syncPlayerIDList)

    return



def CrossServerMsg_FuncTeamDel(msgData):

    ## 子服收到跨服信息 - 队伍删除

    #"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":delTeamDict

    #zoneID = msgData["zoneID"]

    #funcMapID = msgData["funcMapID"]

    delTeamDict = msgData["delTeamDict"]

    for teamID, syncPlayerIDList in delTeamDict.items():

        Sync_FuncTeamDissolve(teamID, syncPlayerIDList)

    return



def CrossServerMsg_FuncTeamList(msgData):

    ## 子服收到跨服信息 - 队伍列表

    queryInfo = msgData["queryInfo"]

    loopIndex = msgData["loopIndex"]

    teamInfoList = msgData["teamInfoList"]

    
    playerID = queryInfo["playerID"]

    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)

    if not curPlayer:

        return

    
    clientPack = ChPyNetSendPack.tagGCFuncTeamList()

    clientPack.FuncMapID = queryInfo["funcMapID"]

    clientPack.FuncMapEx = queryInfo["funcMapEx"]

    clientPack.StartIndex = queryInfo["startIndex"]

    clientPack.QueryCnt = queryInfo["queryCnt"]

    clientPack.HaveSpace = queryInfo["haveSpace"]

    clientPack.IDLimitType = queryInfo["idLimitType"]

    clientPack.SearchMsg = queryInfo["searchMsg"]

    clientPack.SearchLen = len(clientPack.SearchMsg)

    clientPack.LoopIndex = loopIndex

    
    for teamInfo in teamInfoList:

        team = ChPyNetSendPack.tagGCFuncTeam()

        team.TeamID = teamInfo["TeamID"]

        team.CreateTime = teamInfo["CreateTime"]

        team.FuncMapEx = teamInfo["FuncMapEx"]

        team.TeamName = teamInfo["TeamName"]

        team.NameLen = len(team.TeamName)

        team.CaptainID = teamInfo["CaptainID"]

        team.MinLV = teamInfo["MinLV"]

        team.MinFightPower = teamInfo["MinFightPower"] % ChConfig.Def_PerPointValue

        team.MinFightPowerEx = teamInfo["MinFightPower"] / ChConfig.Def_PerPointValue

        team.ServerOnly = teamInfo["ServerOnly"]

        team.NeedCheck = teamInfo["NeedCheck"]

        team.Value1 = teamInfo["Value1"]

        team.Value2 = teamInfo["Value2"]

        
        memberList = []

        for memberInfo in teamInfo["MemberList"]:

            mem = ChPyNetSendPack.tagGCFuncTeamMem()

            mem.ServerID = memberInfo.get("ServerID", 0)

            mem.PlayerID = memberInfo["PlayerID"]

            mem.Name = memberInfo.get("Name", "")

            mem.NameLen = len(mem.Name)

            mem.LV = memberInfo.get("LV", 0)

            mem.Job = memberInfo.get("Job", 0)

            mem.RealmLV = memberInfo.get("RealmLV", 0)

            mem.Face = memberInfo.get("Face", 0)

            mem.FacePic = memberInfo.get("FacePic", 0)

            mem.FightPower = memberInfo.get("FightPower", 0) % ChConfig.Def_PerPointValue

            mem.FightPowerEx = memberInfo.get("FightPower", 0) / ChConfig.Def_PerPointValue

            mem.Value1 = memberInfo["Value1"]

            mem.Value2 = memberInfo["Value2"]

            memberList.append(mem)

            
        team.MemberList = memberList

        team.MemberCount = len(team.MemberList)

        team.ApplyIDList = teamInfo["ApplyIDList"]

        team.ApplyCount = len(team.ApplyIDList)

        
        clientPack.TeamList.append(team)

    clientPack.TeamCount = len(clientPack.TeamList)

    NetPackCommon.SendFakePack(curPlayer, clientPack)

    return



def Sync_FuncTeamRefresh(teamInfo, syncPlayerIDList):

    ## 功能队伍刷新

    if not teamInfo or not syncPlayerIDList:

        return

    
    syncPlayerList = []

    playerManager = GameWorld.GetPlayerManager()

    for playerID in syncPlayerIDList:

        player = playerManager.FindPlayerByID(playerID)

        if player == None or not player.GetInitOK():

            continue

        syncPlayerList.append(player)

        
    if not syncPlayerList:

        return

    
    clientPack = ChPyNetSendPack.tagGCFuncTeamRefresh()

    clientPack.TeamID = teamInfo["TeamID"]

    clientPack.CreateTime = teamInfo["CreateTime"]

    clientPack.FuncMapID = teamInfo["FuncMapID"]

    clientPack.FuncMapEx = teamInfo["FuncMapEx"]

    clientPack.TeamName = teamInfo["TeamName"]

    clientPack.NameLen = len(clientPack.TeamName)

    clientPack.CaptainID = teamInfo["CaptainID"]

    clientPack.MinLV = teamInfo["MinLV"]

    clientPack.MinFightPower = teamInfo["MinFightPower"] % ChConfig.Def_PerPointValue

    clientPack.MinFightPowerEx = teamInfo["MinFightPower"] / ChConfig.Def_PerPointValue

    clientPack.ServerOnly = teamInfo["ServerOnly"]

    clientPack.NeedCheck = teamInfo["NeedCheck"]

    clientPack.Value1 = teamInfo["Value1"]

    clientPack.Value2 = teamInfo["Value2"]

    
    memberInfoList = teamInfo["MemberList"]

    applyInfoList = teamInfo["ApplyList"]

    
    memberList = []

    for memberInfo in memberInfoList:

        mem = ChPyNetSendPack.tagGCFuncTeamRefreshMem()

        mem.ServerID = memberInfo.get("ServerID", 0)

        mem.PlayerID = memberInfo["PlayerID"]

        mem.Name = memberInfo.get("Name", "")

        mem.NameLen = len(mem.Name)

        mem.LV = memberInfo.get("LV", 0)

        mem.Job = memberInfo.get("Job", 0)

        mem.RealmLV = memberInfo.get("RealmLV", 0)

        mem.Face = memberInfo.get("Face", 0)

        mem.FacePic = memberInfo.get("FacePic", 0)

        mem.FightPower = memberInfo.get("FightPower", 0) % ChConfig.Def_PerPointValue

        mem.FightPowerEx = memberInfo.get("FightPower", 0) / ChConfig.Def_PerPointValue

        mem.OfflineValue = memberInfo.get("OfflineValue", 0)

        mem.Value1 = memberInfo["Value1"]

        mem.Value2 = memberInfo["Value2"]

        memberList.append(mem)

        
    applyList, applyIDList = [], []

    for applyInfo in applyInfoList:

        applyP = ChPyNetSendPack.tagGCFuncTeamRefreshApply()

        applyP.ServerID = applyInfo["ServerID"]

        applyP.PlayerID = applyInfo["PlayerID"]

        applyP.Name = applyInfo["Name"]

        applyP.NameLen = len(applyP.Name)

        applyP.LV = applyInfo["LV"]

        applyP.Job = applyInfo["Job"]

        applyP.RealmLV = applyInfo["RealmLV"]

        applyP.Face = applyInfo.get("Face", 0)

        applyP.FacePic = applyInfo.get("FacePic", 0)

        applyP.FightPower = applyInfo["FightPower"] % ChConfig.Def_PerPointValue

        applyP.FightPowerEx = applyInfo["FightPower"] / ChConfig.Def_PerPointValue

        applyList.append(applyP)

        applyIDList.append(applyInfo["PlayerID"])

        
    clientPack.MemberList = memberList

    clientPack.MemberCount = len(clientPack.MemberList)

    clientPack.ApplyIDList = applyIDList

    clientPack.ApplyInfoList = applyList

    clientPack.ApplyCount = len(clientPack.ApplyInfoList)

    
    for player in syncPlayerList:

        NetPackCommon.SendFakePack(player, clientPack)

    return



def Sync_FuncTeamDissolve(teamID, syncPlayerIDList):

    ## 功能队伍解散

    if not teamID or not syncPlayerIDList:

        return

    
    syncPlayerList = []

    playerManager = GameWorld.GetPlayerManager()

    for playerID in syncPlayerIDList:

        player = playerManager.FindPlayerByID(playerID)

        if player == None or not player.GetInitOK():

            continue

        syncPlayerList.append(player)

        
    if not syncPlayerList:

        return

    
    clientPack = ChPyNetSendPack.tagGCFuncTeamDissolve()

    clientPack.TeamID = teamID

    for player in syncPlayerList:

        NetPackCommon.SendFakePack(player, clientPack)

    return



##--------------------------------------------------------------------------------------------------



def GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID):

    ## 获取功能队伍分区信息

    
    funcZoneID = 0

    serverGroupList = []

    
    if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:

        zoneIpyData = CrossBattlefield.GetCrossBattlefieldZoneIpyData(serverGroupID)

        if not zoneIpyData:

            return

        funcZoneID = zoneIpyData.GetZoneID()

        serverGroupList = zoneIpyData.GetServerGroupIDList() # 只通知该分区服务器

        
    return funcZoneID, serverGroupList



def ClientServerMsg_CreateFuncTeam(serverGroupID, msgData):

    ## 收到子服 - 功能队伍创建

    
    zoneID = msgData["zoneID"]

    playerID = msgData["playerID"]

    teamInfo = msgData["teamInfo"]

    cacheBase = msgData["cacheBase"]

    
    funcMapID = teamInfo["funcMapID"]

    
    zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)

    if not zoneInfo:

        return

    funcZoneID, _ = zoneInfo

    
    if zoneID != funcZoneID:

        GameWorld.ErrLog("功能队伍分区不一致，无法创建! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)

        return

    
    canCreate, notifyMark = CheckCanCreateFuncTeam(playerID, teamInfo, zoneID)

    
    # 某些功能创建前检查

    if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:

        pass

    
    newTeam = None

    teamID = 0

    newTeamInfo = {}

    if canCreate:

        PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)

        funcTeamMgr = DBDataMgr.GetFuncTeamMgr()

        newTeam = funcTeamMgr.CreateFuncTeam(playerID, teamInfo, zoneID)

        
    if newTeam:

        teamID = newTeam.GetTeamID()

        newTeamInfo = newTeam.GetSyncDict(True)

        
        # 某些功能创建后处理

        if funcMapID == ChConfig.Def_FBMapID_CrossBattlefield:

            pass

        
    else:

        if not notifyMark:

            notifyMark = "CreatTeamFail"

            
    serverGroupList = [serverGroupID] # 创建仅通知指定服即可

    syncPlayerIDList = [playerID]

    sendMsg = {"infoType":"CreateFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, 
               "teamInfo":newTeamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList, "notifyMark":notifyMark}

    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)

    return



def CheckCanCreateFuncTeam(playerID, teamInfo, zoneID=0, checkInTeam=True):

    ## 检查可否创建功能队伍 - 本服跨服通用

    # @param checkInTeam: 是否检查已经在队伍中，如果功能只允许单个队伍，则需要检查，反之可设置为不检查

    # @return: 是否可创建, 不可创建提示信息

    
    funcMapID = teamInfo["funcMapID"]

    ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

    if not ipyData:

        return False, ""

    
    needName = ipyData.GetNeedName()

    if needName:

        teamName = teamInfo["teamName"]

        if not teamName or len(teamName) > 33:

            # 队伍名不合法

            return False, "TeamNameLenError"

        
        if DirtyList.IsWordForbidden(teamName):

            return False, "TeamNameUnallow"

        
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)

    for funcTeam in teamList:

        if needName:

            if teamName == funcTeam.GetTeamName():

                # 队伍名已存在

                return False, "TeamNameExist"

        
        if checkInTeam:

            if funcTeam.GetMemberByID(playerID):

                # 已经在队伍中

                return False, "AlreadyHaveTeam"

            
    return True, ""



def ClientServerMsg_ChangeFuncTeam(serverGroupID, msgData):

    ## 收到子服 - 功能队伍修改

    
    zoneID = msgData["zoneID"]

    playerID = msgData["playerID"]

    teamInfo = msgData["teamInfo"]

    cacheBase = msgData.get("cacheBase", {})

    
    teamID = teamInfo["teamID"]

    funcMapID = teamInfo["funcMapID"]

    
    zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)

    if not zoneInfo:

        return

    funcZoneID, serverGroupList = zoneInfo

    
    if zoneID != funcZoneID:

        GameWorld.ErrLog("功能队伍分区不一致，无法修改! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)

        return

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        GameWorld.ErrLog("功能队伍不存在! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)

        return

    
    if playerID != funcTeam.GetCaptainID():

        GameWorld.DebugLog("非功能队伍队长，无法修改! funcMapID=%s,teamID=%s,CaptainID=%s" % (funcMapID, teamID, funcTeam.GetCaptainID()), playerID)

        return

    
    if cacheBase:

        PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)

        
    funcTeam.SetMinFightPower(teamInfo["minFightPower"] + teamInfo["minFightPowerEx"] * ChConfig.Def_PerPointValue)

    funcTeam.SetMinLV(teamInfo["minLV"])

    funcTeam.SetServerOnly(teamInfo["serverOnly"])

    funcTeam.SetNeedCheck(teamInfo["needCheck"])

    
    if not funcTeam.GetNeedCheck():

        pass

    
    teamID = funcTeam.GetTeamID()

    teamInfo = funcTeam.GetSyncDict(True)

    syncPlayerIDList = funcTeam.GetSyncPlayerIDList()

    sendMsg = {"infoType":"ChangeFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, 
               "teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}

    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)

    return



def ClientServerMsg_FuncTeamMemOP(serverGroupID, msgData):

    ## 收到子服 - 功能队伍操作

    
    zoneID = msgData["zoneID"]

    playerID = msgData["playerID"] # 操作的玩家ID

    teamID = msgData["teamID"]

    funcMapID = msgData["funcMapID"]

    opType = msgData["opType"]

    opData = msgData["opData"]

    cacheBase = msgData.get("cacheBase", {})

    
    zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)

    if not zoneInfo:

        return

    funcZoneID, serverGroupList = zoneInfo

    
    if zoneID != funcZoneID:

        GameWorld.ErrLog("功能队伍分区不一致，无法操作! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)

        return

    
    if cacheBase:

        PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)

        
    isOK = False

    syncDict = {}

    teamInfo = {}

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        GameWorld.ErrLog("功能队伍不存在! funcMapID=%s,teamID=%s,opType=%s" % (funcMapID, teamID, opType), playerID)

        syncDict["notifyMark"] = "TeamNotExist"

        syncPlayerIDList = [playerID]

    else:

        # 仅队长可操作

        if opType in [Def_FuncTeamOP_JoinAgree, Def_FuncTeamOP_JoinRefuse, Def_FuncTeamOP_Kick, 
                      Def_FuncTeamOP_Transfer, Def_FuncTeamOP_Dissolve]:

            if playerID != funcTeam.GetCaptainID():

                GameWorld.ErrLog("仅队长可操作! funcMapID=%s,teamID=%s,opType=%s,CaptainID=%s" 
                                 % (funcMapID, teamID, opType, funcTeam.GetCaptainID()), playerID)

                return

            
        syncPlayerIDList = funcTeam.GetSyncPlayerIDList()

        
        # 申请加入

        if opType == Def_FuncTeamOP_JoinApply:

            isOK = __DoFuncTeamOP_JoinApply(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            if playerID not in syncPlayerIDList:

                syncPlayerIDList.append(playerID)

                
        # 申请取消

        elif opType == Def_FuncTeamOP_JoinCancel:

            isOK = __DoFuncTeamOP_JoinCancel(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            if playerID not in syncPlayerIDList:

                syncPlayerIDList.append(playerID)

                
        # 同意入队

        elif opType == Def_FuncTeamOP_JoinAgree:

            isOK = __DoFuncTeamOP_JoinAgree(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            
        # 拒绝入队

        elif opType == Def_FuncTeamOP_JoinRefuse:

            isOK = __DoFuncTeamOP_JoinRefuse(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            
        # 退出队伍

        elif opType == Def_FuncTeamOP_Exit:

            isOK = __DoFuncTeamOP_Exit(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            
        # 踢出队伍

        elif opType == Def_FuncTeamOP_Kick:

            isOK = __DoFuncTeamOP_Kick(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            
        # 转让队长

        elif opType == Def_FuncTeamOP_Transfer:

            isOK = __DoFuncTeamOP_Transfer(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

                
        # 解散队伍

        elif opType == Def_FuncTeamOP_Dissolve:

            isOK = __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

            
    if not isOK and not syncDict:

        # 没有执行成功 且 没有需要回复的信息，则不需要回发子服

        return

    
    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if funcTeam:

        teamInfo = funcTeam.GetSyncDict(True)

        
    sendMsg = {"infoType":"FuncTeamMemOP", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, 
               "teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList, "opType":opType}

    sendMsg.update(syncDict)

    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)

    return



def DelTeam(teamID):

    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        GameWorld.ErrLog("删除功能队伍时不存在! teamID=%s" % teamID)

        return

    zoneID = funcTeam.GetZoneID()

    funcMapID = funcTeam.GetFuncMapID()

    syncPlayerIDList = funcTeam.GetSyncPlayerIDList()

    
    funcTeamMgr.DelTeam(teamID)

    
    if not funcTeamMgr.IsLockBatch():

        sendMsg = {"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":{teamID:syncPlayerIDList}}

        CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamDel, sendMsg)

        
    return syncPlayerIDList



def DelTeamByFunc(delFuncMapID):

    GameWorld.Log("清空功能队伍! delFuncMapID=%s" % delFuncMapID)

    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeamMgr.LockBatch()

    delTeamIDList = []

    for key, teamList in funcTeamMgr.funcTeamListDict.items():

        zoneID, funcMapID = key

        if funcMapID != delFuncMapID:

            continue

        delTeamDict = {}

        for funcTeam in teamList[::-1]:

            teamID = funcTeam.GetTeamID()

            syncPlayerIDList = DelTeam(teamID)

            if syncPlayerIDList:

                delTeamDict[teamID] = syncPlayerIDList

            delTeamIDList.append(teamID)

             
        # 按分区处理后一次性同步子服

        zoneIpyData = CrossRealmPlayer.GetCrossZoneIpyDataByZoneID(funcMapID, zoneID)

        serverGroupIDList = zoneIpyData.GetServerGroupIDList() if zoneIpyData else []

        sendMsg = {"zoneID":zoneID, "funcMapID":funcMapID, "delTeamDict":delTeamDict}

        CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamDel, sendMsg, serverGroupIDList)

    funcTeamMgr.UnLockBatch()

    
    delCount = len(delTeamIDList)

    funcTeamMgr.SyncMapFuncTeamMemIDInfo(delTeamIDList)

    return delCount



def DelTealAll():

    delCount = 0

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for index in range(ipyDataMgr.GetFuncTeamSetCount()):

        ipyData = ipyDataMgr.GetFuncTeamSetByIndex(index)

        delCount += DelTeamByFunc(ipyData.GetFuncMapID())

    return delCount



def SendFuncTeamToClientServer(teamID):

    ## 同步队伍明细到子服

    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    funcMapID = funcTeam.GetFuncMapID()

    teamInfo = funcTeam.GetSyncDict(True)

    syncPlayerIDList = funcTeam.GetSyncPlayerIDList()

    
    sendMsg = {"infoType":"", "playerID":0, "funcMapID":funcMapID, 
               "teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}

    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg)

    return



def __DoFuncTeamOP_JoinApply(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 申请加入

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    playerTeamID = funcTeamMgr.GetPlayerTeamID(playerID, funcMapID)

    if playerTeamID:

        GameWorld.Log("已经有功能队伍了，不能再申请! funcMapID=%s,playerTeamID=%s" % (funcMapID, playerTeamID), playerID)

        return

    
    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    if funcTeam.GetMemberByID(playerID):

        GameWorld.Log("已在功能队伍中! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)

        return

    
    if playerID in funcTeam.GetApplyIDList():

        GameWorld.Log("已在功能队伍申请列表中! funcMapID=%s,teamID=%s" % (funcMapID, teamID), playerID)

        return

    
    ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

    if not ipyData:

        return

    
    memberMax = ipyData.GetMemberMax()

    applyMax = ipyData.GetApplyMax()

    reqApplyMax = ipyData.GetReqApplyMax()

    
    if len(funcTeam.GetMemberList()) >= memberMax:

        GameWorld.DebugLog("功能队伍成员已满! funcMapID=%s,teamID=%s,memberMax=%s" % (funcMapID, teamID, memberMax), playerID)

        syncDict["notifyMark"] = "TeamMemFull"

        return

    
    if applyMax and len(funcTeam.GetApplyIDList()) >= applyMax:

        GameWorld.DebugLog("功能队伍申请队列已满! funcMapID=%s,teamID=%s,applyMax=%s" % (funcMapID, teamID, applyMax), playerID)

        syncDict["notifyMark"] = "TeamApplyFull"

        return

    
    minLV = funcTeam.GetMinLV()

    if minLV and minLV > cacheBase.get("LV", 0):

        GameWorld.DebugLog("功能队伍最低等级限制，无法申请! funcMapID=%s,teamID=%s,minLV=%s" % (funcMapID, teamID, minLV), playerID)

        syncDict["notifyMark"] = "TeamLVLimit"

        return

    
    minFightPower = funcTeam.GetMinFightPower()

    if minFightPower and minFightPower > cacheBase.get("FightPower", 0):

        GameWorld.DebugLog("功能队伍最低战力限制，无法申请! funcMapID=%s,teamID=%s,minFightPower=%s" % (funcMapID, teamID, minFightPower), playerID)

        syncDict["notifyMark"] = "TeamFightPowerLimit"

        return

    
    minServerOnly = funcTeam.GetServerOnly()

    if minServerOnly:

        # 待扩展，看是取ServerID，还是 ServerGroupID，需注意GroupID合服后可能不一致的问题

        pass

    
    if reqApplyMax:

        applyTeamIDList = []

        teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)

        for fTeam in teamList:

            if playerID in fTeam.GetApplyIDList():

                applyTeamIDList.append(fTeam.GetTeamID())

        if len(applyTeamIDList) >= reqApplyMax:

            GameWorld.DebugLog("玩家申请加入队伍数已满，无法申请! funcMapID=%s,applyTeamCount=%s, %s" 
                               % (funcMapID, len(applyTeamIDList), applyTeamIDList), playerID)

            syncDict["notifyMark"] = "TeamReqJoinApplyFull"

            return

        
    if funcTeam.GetNeedCheck():

        syncDict["notifyMark"] = "TeamReqJoinApplyOK"

        funcTeam.AddApplyID(playerID)

    else:

        funcTeam.AddTeamMember(playerID)

        
    return True



def __DoFuncTeamOP_JoinCancel(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 申请取消

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    funcTeam.DelApplyID(playerID)

    
    return True



def __DoFuncTeamOP_JoinAgree(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 同意入队

    # @param opData: 目标玩家ID，为0时一键同意

    
    ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

    if not ipyData:

        return

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    applyIDList = funcTeam.GetApplyIDList()

    if not applyIDList:

        return

        
    memberMax = ipyData.GetMemberMax()

    joinPlayerIDList = []

    tagPlayerID = opData

    if tagPlayerID:

        if tagPlayerID not in applyIDList:

            GameWorld.Log("目标玩家不在功能队伍申请列表中! funcMapID=%s,teamID=%s,tagPlayerID=%s not in applyIDList=%s" 
                          % (funcMapID, teamID, tagPlayerID, applyIDList), playerID)

            return

        
        tagPlayerTeamID = funcTeamMgr.GetPlayerTeamID(tagPlayerID, funcMapID)

        if tagPlayerTeamID:

            GameWorld.DebugLog("目标玩家已加入其他功能队伍! funcMapID=%s,tagPlayerID=%s,tagPlayerTeamID=%s" 
                               % (funcMapID, tagPlayerID, tagPlayerTeamID), playerID)

            syncDict["notifyMark"] = "PlayerInOtherTeam"

        else:

            joinPlayerIDList = [tagPlayerID]

    else:

        joinPlayerIDList = [] + applyIDList # 一键同意按申请顺序，如需按战力再做优化

        
    for joinPlayerID in joinPlayerIDList:

        if len(funcTeam.GetMemberList()) >= memberMax:

            GameWorld.DebugLog("功能队伍成员已满! funcMapID=%s,teamID=%s,memberMax=%s" % (funcMapID, teamID, memberMax), playerID)

            break

        tagPlayerTeamID = funcTeamMgr.GetPlayerTeamID(joinPlayerID, funcMapID)

        if tagPlayerTeamID:

            GameWorld.DebugLog("目标玩家已加入其他功能队伍! funcMapID=%s,joinPlayerID=%s,tagPlayerTeamID=%s" 
                               % (funcMapID, joinPlayerID, tagPlayerTeamID), playerID)

            continue

        funcTeam.AddTeamMember(joinPlayerID)

        
    return True



def __DoFuncTeamOP_JoinRefuse(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 拒绝入队

    # @param opData: 目标玩家ID，为0时一键拒绝

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    tagPlayerID = opData

    if tagPlayerID:

        funcTeam.DelApplyID(tagPlayerID)

    else:

        funcTeam.DelApplyIDAll() # 一键拒绝

        
    return True



def __DoFuncTeamOP_Exit(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 退出队伍

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    # 队长退出，直接解散

    if playerID == funcTeam.GetCaptainID():

        return __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict)

    
    funcTeam.DelTeamMember(playerID)

    
    return True



def __DoFuncTeamOP_Kick(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 踢出队伍

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    tagPlayerID = opData

    if not tagPlayerID:

        GameWorld.DebugLog("需指定踢出队伍目标队员! opData=%s" % opData, playerID)

        return

    
    if tagPlayerID == funcTeam.GetCaptainID():

        GameWorld.DebugLog("不能踢队长! opData=%s" % opData, playerID)

        return

    
    funcTeam.DelTeamMember(tagPlayerID)

    
    return True



def __DoFuncTeamOP_Transfer(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 转让队长

    
    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeam = funcTeamMgr.GetFuncTeam(teamID)

    if not funcTeam:

        return

    
    memberIDList = funcTeam.GetMemberIDList()

    tagPlayerID = opData

    if tagPlayerID not in memberIDList:

        GameWorld.Log("目标玩家不是队员，无法转让队长! funcMapID=%s,teamID=%s,tagPlayerID=%s not in %s" 
                      % (funcMapID, teamID, tagPlayerID, memberIDList), playerID)

        return

    
    funcTeam.SetCaptainID(tagPlayerID)

    
    return True



def __DoFuncTeamOP_Dissolve(zoneID, funcMapID, teamID, playerID, opType, opData, cacheBase, syncDict):

    ## 解散队伍

    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    funcTeamMgr.DelTeam(teamID)

    return True



def ClientServerMsg_QueryFuncTeam(serverGroupID, msgData):

    ## 收到子服 - 查找队伍列表

    
    zoneID = msgData["zoneID"]

    playerID = msgData["playerID"]

    funcMapID = msgData["funcMapID"]

    cacheBase = msgData.get("cacheBase", {})

    
    zoneInfo = GetFuncTeamMapIDZoneInfo(funcMapID, serverGroupID)

    if not zoneInfo:

        return

    funcZoneID, _ = zoneInfo

    
    if zoneID != funcZoneID:

        GameWorld.ErrLog("功能队伍分区不一致，无法查询! funcMapID=%s,zoneID=%s != %s" % (funcMapID, zoneID, funcZoneID), playerID)

        return

    
    if cacheBase:

        PlayerViewCache.UpdCrossCacheBase(playerID, cacheBase)

        
    # 非列表查询，返回玩家相关队伍

    if "startIndex" not in msgData:

        syncPlayerIDList = [playerID]

        serverGroupList = [serverGroupID]

        
        funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

        # 申请的队伍

        funcTeamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)

        for funcTeam in funcTeamList:

            if playerID not in funcTeam.GetApplyIDList():

                continue

            teamID = funcTeam.GetTeamID()

            teamInfo = funcTeam.GetSyncDict(True)

            sendMsg = {"infoType":"QueryPlayerFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, 
                       "teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}

            CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)

            
        # 玩家所属队伍

        teamID = funcTeamMgr.GetPlayerTeamID(playerID, funcMapID)

        funcTeam = funcTeamMgr.GetFuncTeam(teamID)

        teamInfo = funcTeam.GetSyncDict(True) if funcTeam else {}

        sendMsg = {"infoType":"QueryPlayerFuncTeam", "zoneID":zoneID, "playerID":playerID, "funcMapID":funcMapID, 
                   "teamInfo":teamInfo, "teamID":teamID, "syncPlayerIDList":syncPlayerIDList}

        CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamInfo, sendMsg, serverGroupList)

        return

    
    # 列表查询

    funcMapEx = msgData["funcMapEx"]

    startIndex = msgData["startIndex"]

    queryCnt = msgData["queryCnt"]

    haveSpace = msgData["haveSpace"]

    idLimitType = msgData["idLimitType"]

    searchMsg = msgData["searchMsg"]

    if queryCnt <= 0:

        queryCnt = 20

    queryCnt = min(100, queryCnt) # 默认20，最大100

    
    ipyData = IpyGameDataPY.GetIpyGameData("FuncTeamSet", funcMapID)

    if not ipyData:

        return

    memberMax = ipyData.GetMemberMax()

    
    idLimitTypeDict = {1:"FamilyID", 2:"ServerGroupID", 3:"AccID"}

    loopIndex = startIndex

    teamInfoList = []

    funcTeamMgr = PyDataManager.GetDBPyFuncTeamManager()

    teamList = funcTeamMgr.GetFuncTeamList(zoneID, funcMapID)

    for index in xrange(startIndex, len(teamList)):

        loopIndex = index + 1

        funcTeam = teamList[index]

        if searchMsg:

            # 精确匹配队伍名、队伍ID的插入在最前面

            if searchMsg == funcTeam.GetTeamName() or searchMsg == str(funcTeam.GetTeamID()):

                teamInfoList.insert(0, funcTeam.GetSyncDict(False))

            elif searchMsg in funcTeam.GetTeamName():

                teamInfoList.append(funcTeam.GetSyncDict(False))

            else:

                continue

        else:

            if funcMapEx != 0 and funcMapEx != funcTeam.GetFuncMapEx():

                continue

            if haveSpace and len(funcTeam.GetMemberList()) >= memberMax:

                #GameWorld.DebugLog("已满员，不加入列表查看 teamID=%s" % funcTeam.GetTeamID())

                continue

            if idLimitType in idLimitTypeDict:

                limitAttrName = idLimitTypeDict[idLimitType]

                curIDValue = cacheBase.get(limitAttrName, 0)

                captainID = funcTeam.GetCaptainID()

                cacheDict = PlayerViewCache.GetCachePropDataDict(PlayerViewCache.FindViewCache(captainID))

                teamIDValue = cacheDict.get(limitAttrName, 0)

                if limitAttrName == "AccID":

                    curIDValue = GameWorld.GetAccIDServerID(str(curIDValue))

                    teamIDValue = GameWorld.GetAccIDServerID(str(teamIDValue))

                    
                if not curIDValue or curIDValue != teamIDValue:

                    #GameWorld.DebugLog("没有或不同ID限制，不加入列表查看! idLimitType=%s,curIDValue=%s != %s, teamID=%s, captainID=%s" 
                    #                   % (idLimitType, curIDValue, teamIDValue, funcTeam.GetTeamID(), captainID))

                    continue

            teamInfoList.append(funcTeam.GetSyncDict(False))

            
        if len(teamInfoList) >= queryCnt:

            break

        
    serverGroupList = [serverGroupID] # 仅通知查询服即可

    sendMsg = {"teamInfoList":teamInfoList, "loopIndex":loopIndex, "queryInfo":msgData}

    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_FuncTeamList, sendMsg, serverGroupList)

    return


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/PyGameData.py

@@ -57,8 +57,6 @@
g_teamPlayerDict = {} # 地图队伍对应玩家ID列表，含离线玩家 {teamID:[playerID, ...], ...}

g_teamPlayerInfoDict = {} # 地图队伍对应玩家ID信息 {teamID:{playerID:{k:v, ...}, ...}



g_funcTeamPlayerDict = {} # 功能队伍玩家ID列表 {(zoneID, funcMapID): {teamID:[playerID, ...], ...}, ...}



g_unLoginOKPlayerMailInfo = {} # GameServer 未登录成功前需要发送的邮件缓存，防止登录失败不存db导致重复发送邮件 {playerID:[[待发送邮件内容信息], ...], ...}

g_disconnectPlayer = {} # 在本地图离线的玩家信息 {playerID:[tick, posX, posY], ...}

g_lastExitFBType = {} # 最后一个离开副本信息 {fbIndex:[exitType, tick], ...} exitType: 1-掉线，2-主动退出


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/PyMongoDB/Collections/CollectionDefine.py

@@ -5,6 +5,8 @@
#-------------------------------------------------------------------------------

#

#卡牌服务器表

UCN_DBFuncTeamMem="tagDBFuncTeamMem"

UCN_DBFuncTeam="tagDBFuncTeam"

UCN_DBGameRec="tagDBGameRec"

UCN_DBFamilyAction="tagDBFamilyAction"

UCN_DBFamilyMem="tagDBFamilyMem"


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/PyMongoDB/Collections/DataServerPlayerData.py

@@ -28915,3 +28915,425 @@
        return output





# 功能队伍表 #tagDBFuncTeam

class tagDBFuncTeam(Structure):

    _pack_ = 1

    _fields_ = [

        ('TeamID', ctypes.c_ulong),

        ('TeamName', ctypes.c_char * 33),

        ('ZoneID', ctypes.c_ubyte),

        ('FuncMapID', ctypes.c_ulong),

        ('FuncMapEx', ctypes.c_ulong),

        ('CreateTime', ctypes.c_ulong),

        ('CaptainID', ctypes.c_ulong),

        ('MinLV', ctypes.c_ushort),

        ('MinFightPower', ctypes.c_ulong),

        ('MinFightPowerEx', ctypes.c_ulong),

        ('ServerOnly', ctypes.c_ubyte),

        ('NeedCheck', ctypes.c_ubyte),

        ('ApplyIDLen', ctypes.c_ushort),

        ('ApplyIDList', ctypes.c_char_p),

        ('Value1', ctypes.c_ulong),

        ('Value2', ctypes.c_ulong),

        ('Value3', ctypes.c_ulong),

        ('Value4', ctypes.c_ulong),

        ('Value5', ctypes.c_ulong),

        ('ADOResult', ctypes.c_ulong),

    ]



    def __init__(self):

        Structure.__init__(self)

        self.clear()



    def clear(self):

        self.TeamID = 0

        self.TeamName = ''

        self.ZoneID = 0

        self.FuncMapID = 0

        self.FuncMapEx = 0

        self.CreateTime = 0

        self.CaptainID = 0

        self.MinLV = 0

        self.MinFightPower = 0

        self.MinFightPowerEx = 0

        self.ServerOnly = 0

        self.NeedCheck = 0

        self.ApplyIDLen = 0

        self.ApplyIDList = ''

        self.Value1 = 0

        self.Value2 = 0

        self.Value3 = 0

        self.Value4 = 0

        self.Value5 = 0



    def readData(self, buf, pos = 0, length = 0):

        if not pos <= length:

            msg = error.formatMsg('error', error.ERROR_NO_148, '(pos = %s) > (length = %s)'%(pos, length))

            mylog.error(msg)

            return -1

        if len(buf) < pos + self.getLength():

            msg = error.formatMsg('error', error.ERROR_NO_149, 'len = %s while %s expected!'%(len(buf) - pos, self.getLength()))

            mylog.error(msg)

        self.clear()

        self.TeamID, pos = CommFunc.ReadDWORD(buf, pos)

        self.TeamName, pos = CommFunc.ReadString(buf, pos, 33)

        self.ZoneID, pos = CommFunc.ReadBYTE(buf, pos)

        self.FuncMapID, pos = CommFunc.ReadDWORD(buf, pos)

        self.FuncMapEx, pos = CommFunc.ReadDWORD(buf, pos)

        self.CreateTime, pos = CommFunc.ReadDWORD(buf, pos)

        self.CaptainID, pos = CommFunc.ReadDWORD(buf, pos)

        self.MinLV, pos = CommFunc.ReadWORD(buf, pos)

        self.MinFightPower, pos = CommFunc.ReadDWORD(buf, pos)

        self.MinFightPowerEx, pos = CommFunc.ReadDWORD(buf, pos)

        self.ServerOnly, pos = CommFunc.ReadBYTE(buf, pos)

        self.NeedCheck, pos = CommFunc.ReadBYTE(buf, pos)

        self.ApplyIDLen, pos = CommFunc.ReadWORD(buf, pos)

        tmp, pos = CommFunc.ReadString(buf, pos, self.ApplyIDLen)

        self.ApplyIDList = ctypes.c_char_p(tmp)

        self.Value1, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value2, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value3, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value4, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value5, pos = CommFunc.ReadDWORD(buf, pos)

        return self.getLength()



    def getBuffer(self):

        buf = ''

        buf = CommFunc.WriteDWORD(buf, self.TeamID)

        buf = CommFunc.WriteString(buf, sizeof(ctypes.c_char) * 33, self.TeamName)

        buf = CommFunc.WriteBYTE(buf, self.ZoneID)

        buf = CommFunc.WriteDWORD(buf, self.FuncMapID)

        buf = CommFunc.WriteDWORD(buf, self.FuncMapEx)

        buf = CommFunc.WriteDWORD(buf, self.CreateTime)

        buf = CommFunc.WriteDWORD(buf, self.CaptainID)

        buf = CommFunc.WriteWORD(buf, self.MinLV)

        buf = CommFunc.WriteDWORD(buf, self.MinFightPower)

        buf = CommFunc.WriteDWORD(buf, self.MinFightPowerEx)

        buf = CommFunc.WriteBYTE(buf, self.ServerOnly)

        buf = CommFunc.WriteBYTE(buf, self.NeedCheck)

        buf = CommFunc.WriteWORD(buf, self.ApplyIDLen)

        buf = CommFunc.WriteString(buf, self.ApplyIDLen, self.ApplyIDList)

        buf = CommFunc.WriteDWORD(buf, self.Value1)

        buf = CommFunc.WriteDWORD(buf, self.Value2)

        buf = CommFunc.WriteDWORD(buf, self.Value3)

        buf = CommFunc.WriteDWORD(buf, self.Value4)

        buf = CommFunc.WriteDWORD(buf, self.Value5)

        return buf



    def getLength(self):

        length = 0

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_char) * 33

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ushort)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ubyte)

        length += sizeof(ctypes.c_ushort)

        length += self.ApplyIDLen

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        length += sizeof(ctypes.c_ulong)

        return length



    def getRecord(self):

        '''组织存储记录'''

        rec = {}

        rec[u'TeamID'] = self.TeamID

        rec[u'TeamName'] = fix_incomingText(self.TeamName)

        rec[u'ZoneID'] = self.ZoneID

        rec[u'FuncMapID'] = self.FuncMapID

        rec[u'FuncMapEx'] = self.FuncMapEx

        rec[u'CreateTime'] = self.CreateTime

        rec[u'CaptainID'] = self.CaptainID

        rec[u'MinLV'] = self.MinLV

        rec[u'MinFightPower'] = self.MinFightPower

        rec[u'MinFightPowerEx'] = self.MinFightPowerEx

        rec[u'ServerOnly'] = self.ServerOnly

        rec[u'NeedCheck'] = self.NeedCheck

        rec[u'ApplyIDLen'] = self.ApplyIDLen

        rec[u'ApplyIDList'] = fix_incomingText(self.ApplyIDList)

        rec[u'Value1'] = self.Value1

        rec[u'Value2'] = self.Value2

        rec[u'Value3'] = self.Value3

        rec[u'Value4'] = self.Value4

        rec[u'Value5'] = self.Value5

        return rec



    def readRecord(self, rec):

        '''由于MongoDB读出来是unicode,所有字符串需要进行转换'''

        self.TeamID = rec.get(u'TeamID', 0)

        self.TeamName = fix_outgoingText(rec.get(u'TeamName', u''))

        self.ZoneID = rec.get(u'ZoneID', 0)

        self.FuncMapID = rec.get(u'FuncMapID', 0)

        self.FuncMapEx = rec.get(u'FuncMapEx', 0)

        self.CreateTime = rec.get(u'CreateTime', 0)

        self.CaptainID = rec.get(u'CaptainID', 0)

        self.MinLV = rec.get(u'MinLV', 0)

        self.MinFightPower = rec.get(u'MinFightPower', 0)

        self.MinFightPowerEx = rec.get(u'MinFightPowerEx', 0)

        self.ServerOnly = rec.get(u'ServerOnly', 0)

        self.NeedCheck = rec.get(u'NeedCheck', 0)

        self.ApplyIDLen = rec.get(u'ApplyIDLen', 0)

        self.ApplyIDList = fix_outgoingText(rec.get(u'ApplyIDList', u''))

        self.Value1 = rec.get(u'Value1', 0)

        self.Value2 = rec.get(u'Value2', 0)

        self.Value3 = rec.get(u'Value3', 0)

        self.Value4 = rec.get(u'Value4', 0)

        self.Value5 = rec.get(u'Value5', 0)



#Can not implement adoLoadStr method:No key defined!

#Can not implement adoInsertStr method:No key defined!

#Can not implement adoUpdateStr method:No key defined!

#Can not implement adoUpdateStr method:No key defined!

#Can not implement adoCheckUpdateStr method:No key defined!

#Can not implement adoCheckUpdateExStr method:No key defined!



    def getAdoRecords(self, resultCollection):

        '''查询结果打包成二进制流'''

        result = ''

        result = CommFunc.WriteDWORD(result, resultCollection.count())

        for rec in resultCollection:

            self.readRecord(rec)

            result += self.getBuffer()

        return result



#Can not implement adoQueryIndexStr method:No key defined!



    def adoQueryCustom(self, collection, queryDict):

        '''自定义查询'''

        resultCollection = collection.find(queryDict)



        return self.getAdoRecords(resultCollection)





    def adoQueryAll(self, collection):

        '''查询所有''' 
        resultCollection = collection.find()

         
        return self.getAdoRecords(resultCollection)



#Can not implement adoDeleteByIndexStr method:No key defined!

    def outputString(self):

        output = '''// 功能队伍表 #tagDBFuncTeam:

            TeamID = %s,

            TeamName = %s,

            ZoneID = %s,

            FuncMapID = %s,

            FuncMapEx = %s,

            CreateTime = %s,

            CaptainID = %s,

            MinLV = %s,

            MinFightPower = %s,

            MinFightPowerEx = %s,

            ServerOnly = %s,

            NeedCheck = %s,

            ApplyIDLen = %s,

            ApplyIDList = %s,

            Value1 = %s,

            Value2 = %s,

            Value3 = %s,

            Value4 = %s,

            Value5 = %s,

            ADOResult = %s,

            '''%(

                self.TeamID,

                self.TeamName,

                self.ZoneID,

                self.FuncMapID,

                self.FuncMapEx,

                self.CreateTime,

                self.CaptainID,

                self.MinLV,

                self.MinFightPower,

                self.MinFightPowerEx,

                self.ServerOnly,

                self.NeedCheck,

                self.ApplyIDLen,

                self.ApplyIDList,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

                self.ADOResult,

            )

        return output



    def dumpString(self):

        output = '''%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s'''%(

                self.TeamID,

                self.TeamName,

                self.ZoneID,

                self.FuncMapID,

                self.FuncMapEx,

                self.CreateTime,

                self.CaptainID,

                self.MinLV,

                self.MinFightPower,

                self.MinFightPowerEx,

                self.ServerOnly,

                self.NeedCheck,

                self.ApplyIDLen,

                self.ApplyIDList,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

            )

        return output



    #Char数组类型Set接口,使用该接口对此类型数据赋值，防止赋值的数据过长报错

    def SetTeamName(self,Str):

        if len(Str)<=33:

            self.TeamName = Str

        else:

            self.TeamName = Str[:33]

            


# 功能队伍成员表 #tagDBFuncTeamMem

class tagDBFuncTeamMem(Structure):

    _pack_ = 1

    _fields_ = [

        ('TeamID', ctypes.c_ulong),

        ('PlayerID', ctypes.c_ulong),

        ('Value1', ctypes.c_ulong),

        ('Value2', ctypes.c_ulong),

        ('Value3', ctypes.c_ulong),

        ('Value4', ctypes.c_ulong),

        ('Value5', ctypes.c_ulong),

        ('ADOResult', ctypes.c_ulong),

    ]



    def __init__(self):

        Structure.__init__(self)

        self.clear()





    def clear(self):

        memset(addressof(self), 0, self.getLength())



    def readData(self, buf, pos = 0, length = 0):

        if not pos <= length:

            msg = error.formatMsg('error', error.ERROR_NO_148, '(pos = %s) > (length = %s)'%(pos, length))

            mylog.error(msg)

            return -1

        if len(buf) < pos + self.getLength():

            msg = error.formatMsg('error', error.ERROR_NO_149, 'len = %s while %s expected!'%(len(buf) - pos, self.getLength()))

            mylog.error(msg)

        self.clear()

        self.TeamID, pos = CommFunc.ReadDWORD(buf, pos)

        self.PlayerID, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value1, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value2, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value3, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value4, pos = CommFunc.ReadDWORD(buf, pos)

        self.Value5, pos = CommFunc.ReadDWORD(buf, pos)

        return self.getLength()





    def getBuffer(self):

        buf = create_string_buffer(self.getLength())

        memmove(addressof(buf), addressof(self), self.getLength())

        return string_at(addressof(buf), self.getLength())



    def getLength(self):

        return sizeof(tagDBFuncTeamMem)



    def getRecord(self):

        '''组织存储记录'''

        rec = {}

        rec[u'TeamID'] = self.TeamID

        rec[u'PlayerID'] = self.PlayerID

        rec[u'Value1'] = self.Value1

        rec[u'Value2'] = self.Value2

        rec[u'Value3'] = self.Value3

        rec[u'Value4'] = self.Value4

        rec[u'Value5'] = self.Value5

        return rec



    def readRecord(self, rec):

        '''由于MongoDB读出来是unicode,所有字符串需要进行转换'''

        self.TeamID = rec.get(u'TeamID', 0)

        self.PlayerID = rec.get(u'PlayerID', 0)

        self.Value1 = rec.get(u'Value1', 0)

        self.Value2 = rec.get(u'Value2', 0)

        self.Value3 = rec.get(u'Value3', 0)

        self.Value4 = rec.get(u'Value4', 0)

        self.Value5 = rec.get(u'Value5', 0)



#Can not implement adoLoadStr method:No key defined!

#Can not implement adoInsertStr method:No key defined!

#Can not implement adoUpdateStr method:No key defined!

#Can not implement adoUpdateStr method:No key defined!

#Can not implement adoCheckUpdateStr method:No key defined!

#Can not implement adoCheckUpdateExStr method:No key defined!



    def getAdoRecords(self, resultCollection):

        '''查询结果打包成二进制流'''

        result = ''

        result = CommFunc.WriteDWORD(result, resultCollection.count())

        for rec in resultCollection:

            self.readRecord(rec)

            result += self.getBuffer()

        return result



#Can not implement adoQueryIndexStr method:No key defined!



    def adoQueryCustom(self, collection, queryDict):

        '''自定义查询'''

        resultCollection = collection.find(queryDict)



        return self.getAdoRecords(resultCollection)





    def adoQueryAll(self, collection):

        '''查询所有''' 
        resultCollection = collection.find()

         
        return self.getAdoRecords(resultCollection)



#Can not implement adoDeleteByIndexStr method:No key defined!

    def outputString(self):

        output = '''// 功能队伍成员表 #tagDBFuncTeamMem:

            TeamID = %s,

            PlayerID = %s,

            Value1 = %s,

            Value2 = %s,

            Value3 = %s,

            Value4 = %s,

            Value5 = %s,

            ADOResult = %s,

            '''%(

                self.TeamID,

                self.PlayerID,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

                self.ADOResult,

            )

        return output



    def dumpString(self):

        output = '''%1s\t%1s\t%1s\t%1s\t%1s\t%1s\t%1s'''%(

                self.TeamID,

                self.PlayerID,

                self.Value1,

                self.Value2,

                self.Value3,

                self.Value4,

                self.Value5,

            )

        return output






 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/PyMongoDB/LogicProcess/UserCtrlDB.py

@@ -3434,6 +3434,16 @@
        data += DBGameRec.adoQueryAll(collection)

        mylog.info("tagDBGameRec ok")

        

        collection = db[UCN_DBFuncTeam]

        DBFuncTeam = DataServerPlayerData.tagDBFuncTeam()

        data += DBFuncTeam.adoQueryAll(collection)

        mylog.info("tagDBFuncTeam ok")

        
        collection = db[UCN_DBFuncTeamMem]

        DBFuncTeamMem = DataServerPlayerData.tagDBFuncTeamMem()

        data += DBFuncTeamMem.adoQueryAll(collection)

        mylog.info("tagDBFuncTeamMem ok")

        
        mylog.info('readGameWorldData len:%s' % len(data))

        return data

    

@@ -3456,6 +3466,8 @@
            gameDataReadPos = self.savegameServerWorldData(saveData, gameDataReadPos, UCN_DBFamilyMem, DataServerPlayerData.tagDBFamilyMem, db)

            gameDataReadPos = self.savegameServerWorldData(saveData, gameDataReadPos, UCN_DBFamilyAction, DataServerPlayerData.tagDBFamilyAction, db)

            gameDataReadPos = self.savegameServerWorldData(saveData, gameDataReadPos, UCN_DBGameRec, DataServerPlayerData.tagDBGameRec, db)

            gameDataReadPos = self.savegameServerWorldData(saveData, gameDataReadPos, UCN_DBFuncTeam, DataServerPlayerData.tagDBFuncTeam, db)

            gameDataReadPos = self.savegameServerWorldData(saveData, gameDataReadPos, UCN_DBFuncTeamMem, DataServerPlayerData.tagDBFuncTeamMem, db)

            

            mylog.info('saveGameWorldData ok!')