#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package DB.StructData.DBFamily
#
# @todo:DB¼Ò×åÏà¹Ø
# @author hxp
# @date 2025-05-09
# @version 1.0
#
# ÏêϸÃèÊö: DB¼Ò×åÏà¹Ø
#
#-------------------------------------------------------------------------------
#"""Version = 2025-05-09 12:20"""
#-------------------------------------------------------------------------------

import ChPlayer
import DBStruct
import CommFunc
import GameWorld
import ShareDefine
import PlayerViewCache
import ChPyNetSendPack
import NetPackCommon
import IpyGameDataPY
import PyMongoMain
import DBDataMgr
import CrossMgr
import CrossMsg
import ChConfig
import DBComm

import time

#FamilyUpperLimitCount = 2000

class FamilyActionData():
    
    def __init__(self, dbData=None, dataToJson=False):
        self.__dbData = DBStruct.tagDBFamilyAction() if not dbData else dbData
        self.__dataDict = DBComm.UserDataDict(self.__dbData, "Data", "DataLen", dataToJson)
        return
    
    def GetFamilyID(self): return self.__dbData.FamilyID
    def GetActionType(self): return self.__dbData.ActionType
    def GetName(self): return self.__dbData.Name
    def SetName(self, name): self.__dbData.Name = name
    def GetTime(self): return self.__dbData.Time
    def SetTime(self, setTime): self.__dbData.Time = setTime
    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 GetValue6(self): return self.__dbData.Value6
    def SetValue6(self, value6): self.__dbData.Value6 = value6
    def GetUserDict(self): return self.__dataDict.GetData()
    def GetUserData(self): return self.__dataDict.ToString()
    def SetUserData(self, value): self.__dataDict.SetData(value)
    def GetBuffer(self):
        self.__dataDict.ToString()
        return self.__dbData.getBuffer()
    
class FamilyAction():
    
    def __init__(self):
        self.familyID = 0
        self.actionType = 0
        self.__actionDataList = []
        return
    
    def InitActionInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        dataToJson = True
        # ĬÈÏʹÓà dataToJson£¬Èç¹û²»ÐèÒªµÄ¿É¸ù¾Ý ActionType ÔÚÕâÀï´¦Àí
        if dbData.ActionType in []:
            dataToJson = False
        actionData = FamilyActionData(dbData, dataToJson)
        self.__actionDataList.append(actionData)
        return actionData
    
    def AddAction(self, maxCount=None):
        ## Ìí¼ÓÏÉÃËActionÊý¾Ý
        # @param maxCount: ¿É´«ÈëÓÉÅäÖþö¶¨µÄ×î´óÌõÊý£¬Èç¹ûΪNoneÔò½øÒ»²½È¡³ÌÐòĬÈÏÉ趨µÄ×î´óÌõÊý£¬¶¼Ã»ÅäÖõĻ°Ä¬Èϲ»ÏÞÌõÊý
        
        fullClear = True
        if maxCount == None:
            maxCount = ShareDefine.ActionTypeSaveCnt.get(self.actionType, 0)
        actionData = None
        if maxCount and self.Count() >= maxCount:
            if not fullClear:
                #³¬¹ý¼Ç¼¼Ç¼²»ÁËÁË
                return actionData
            self.SortByTime()  # °´Ê±¼äÉýÐò
            self.DelAction(0)  # ɾ³ýµÚÒ»¸ö
            
        dbData = DBStruct.tagDBFamilyAction()
        dbData.FamilyID = self.familyID
        dbData.ActionType = self.actionType
        dbData.Time = int(time.time())
        
        actionData = self.InitActionInstance(dbData)
        return actionData
    
    def SortByTime(self):
        self.__actionDataList.sort(key=lambda f: (f.GetTime()))
        return
    
    def DelAction(self, index):
        if 0 <= index < len(self.__actionDataList):
            self.__actionDataList.pop(index)
        return
    
    def GetOneAction(self, isAdd=False):
        ## »ñÈ¡Ò»¸öactionÊý¾Ý£¬½öÕë¶ÔÖ»´æÒ»ÌõÊý¾ÝµÄÀàÐÍ
        aData = None
        if self.Count():
            aData = self.At(0)
        elif isAdd:
            aData = self.AddAction()
        return aData
    
    def Count(self): return len(self.__actionDataList)
    def At(self, index):
        aData = None
        if 0 <= index < len(self.__actionDataList):
            aData = self.__actionDataList[index]
        elif False:
            aData = FamilyActionData()
        return aData
    
    def GetActionDataByValue1(self, value1, isAdd=False):
        ## »ñÈ¡Action¸ù¾ÝValue1
        # @return: None or findActionData
        findActionData = None
        for actionData in self.__actionDataList:
            if actionData.GetValue1() == value1:
                findActionData = actionData
                break
        if not findActionData and isAdd:
            findActionData = self.AddAction()
            findActionData.SetValue1(value1)
        return findActionData
    
    def DelActionDataByValue1(self, value1):
        ## ɾ³ýAction¸ù¾ÝValue1
        for actionData in self.__actionDataList[::-1]:
            if actionData.GetValue1() == value1:
                self.__actionDataList.remove(actionData)
                break
        return
    
class FamilyActionMgr():
    
    def __init__(self):
        self.__familyActionDict = {} # ÏÉÃËactionÐÅÏ¢ {familyID:{actionType:FamilyAction, ...}, ...}
        return
    
    def GetFamilyAction(self, familyID, actionType):
        if not familyID:
            return FamilyAction()
        if familyID not in self.__familyActionDict:
            self.__familyActionDict[familyID] = {}
        actionDict = self.__familyActionDict[familyID]
        if actionType in actionDict:
            action = actionDict[actionType]
        else:
            action = FamilyAction()
            action.familyID = familyID
            action.actionType = actionType
            actionDict[actionType] = action
        return action
    
    def DelFamilyAction(self, familyID, actionType):
        if familyID not in self.__familyActionDict:
            return
        actionDict = self.__familyActionDict[familyID]
        actionDict.pop(actionType, None)
        return
    
    def ClearFamilyAction(self, familyID):
        self.__familyActionDict.pop(familyID, None)
        return
    
    def GetActionTypeList(self, familyID):
        ## »ñÈ¡ÓÐÊý¾ÝµÄactionÀàÐÍÁбí
        return self.__familyActionDict.get(familyID, {}).keys()
    
class FamilyMem():
    
    def __init__(self, dbData=None, family=None):
        self.__dbData = DBStruct.tagDBFamilyMem() if not dbData else dbData
        self.__family = family
        return
    
    def GetFamily(self):
        if not self.__family:
            self.__family = DBDataMgr.GetFamilyMgr().FindFamily(self.__dbData.FamilyID)
        return self.__family
    def GetPlayerID(self): return self.__dbData.PlayerID
    def GetFamilyID(self): return self.__dbData.FamilyID
    def GetJoinTime(self): return self.__dbData.JoinTime
    def GetPlayerName(self): return self.__dbData.PlayerName
    def SetPlayerName(self, playerName): self.__dbData.PlayerName = playerName
    def GetLV(self): return self.__dbData.LV
    def SetLV(self, lv): self.__dbData.LV = lv
    def GetJob(self): return self.__dbData.Job
    def SetJob(self, job): self.__dbData.Job = job
    def GetRealmLV(self): return self.__dbData.RealmLV
    def SetRealmLV(self, realmLV): self.__dbData.RealmLV = realmLV
    def GetFace(self): return self.__dbData.Face
    def SetFace(self, face): self.__dbData.Face = face
    def GetFacePic(self): return self.__dbData.FacePic
    def SetFacePic(self, facePic): self.__dbData.FacePic = facePic
    def GetTitleID(self): return self.__dbData.TitleID
    def SetTitleID(self, titleID): self.__dbData.TitleID = titleID
    def GetFightPower(self): return self.__dbData.FightPower
    def GetFightPowerEx(self): return self.__dbData.FightPowerEx
    def GetFightPowerTotal(self): return self.__dbData.FightPowerEx * ChConfig.Def_PerPointValue + self.__dbData.FightPower
    def SetFightPowerTotal(self, fightPowerTotal):
        self.__dbData.FightPower = fightPowerTotal % ChConfig.Def_PerPointValue
        self.__dbData.FightPowerEx = fightPowerTotal / ChConfig.Def_PerPointValue
        return
    def GetServerID(self): return self.__dbData.ServerID
    def SetServerID(self, serverID): self.__dbData.ServerID = serverID
    def GetOffTime(self): return self.__dbData.OffTime
    def SetOffTime(self, offTime): self.__dbData.OffTime = offTime
    def GetFmLV(self): return self.__dbData.FmLV
    def SetFmLV(self, fmLV): self.__dbData.FmLV = fmLV
    def GetContribTotal(self): return self.__dbData.ContribTotal
    def SetContribTotal(self, contribTotal): self.__dbData.ContribTotal = contribTotal
    def GetContribDay(self): return self.__dbData.ContribDay
    def SetContribDay(self, contribDay): self.__dbData.ContribDay = contribDay
    def GetDonateCntTotal(self): return self.__dbData.DonateCntTotal
    def SetDonateCntTotal(self, donateCntTotal): self.__dbData.DonateCntTotal = donateCntTotal
    def GetDonateCntDay(self): return self.__dbData.DonateCntDay
    def SetDonateCntDay(self, donateCntDay): self.__dbData.DonateCntDay = donateCntDay
    def GetBuffer(self): return self.__dbData.getBuffer()
    
    def RefreshMemberByID(self, playerID):
        '''ˢгÉÔ±ÐÅÏ¢£¬ÏÉÃ˳ÉÔ±ÊôÓÚÓÀ¾Ã¹¦ÄÜÊý¾Ý£¬³ý·ÇÏÉÃ˽âÉ¢£¬ËùÒÔµ¥¶À´æÒ»·Ý³ÉÔ±»ù´¡ÐÅÏ¢£¬Ö§³ÖÀëÏßÍæ¼Ò£¬Ö±½ÓʹÓò鿴»º´æ¸üÐÂ
        @return: Õ½Á¦ÊÇ·ñ±ä¸ü
        '''
        if playerID != self.GetPlayerID():
            return
        viewCache = PlayerViewCache.FindViewCache(playerID)
        if not viewCache:
            return
        self.SetPlayerName(viewCache.GetPlayerName())
        self.SetLV(viewCache.GetLV())
        self.SetJob(viewCache.GetJob())
        self.SetRealmLV(viewCache.GetRealmLV())
        self.SetFace(viewCache.GetFace())
        self.SetFacePic(viewCache.GetFacePic())
        self.SetTitleID(viewCache.GetTitleID())
        self.SetServerID(viewCache.GetServerID())
        if not self.GetOffTime(): # ÓÐÀëÏßʱ¼äÊý¾ÝÁË£¬ÒÔ³ÉÔ±×Ô¼ºµÄΪ׼
            self.SetOffTime(viewCache.GetOffTime())
        fpChange = False
        fightPowerTotal = viewCache.GetFightPowerTotal()
        if self.GetFightPowerTotal() != fightPowerTotal:
            self.SetFightPowerTotal(fightPowerTotal)
            fpChange = True
            family = self.GetFamily()
            if family:
                family.RefrshFightPowerTotal()
        return fpChange
    
class Family():
    
    def __init__(self, dbData=None):
        self.__dbData = DBStruct.tagDBFamily() if not dbData else dbData
        self.__memberList = [] # [FamilyMem, ...]
        self.__memberDict = {} # ³ÉÔ±×Öµä {playerID:FamilyMem, ...}
        self.__familyMgr = DBDataMgr.GetFamilyMgr()
        self.__actionMgr = DBDataMgr.GetFamilyActionMgr()
        return
    
    def GetID(self): return self.__dbData.ID
    def GetCreateTime(self): return self.__dbData.CreateTime
    def GetServerID(self): return self.__dbData.ServerID
    def GetName(self): return self.__dbData.Name
    def SetName(self, name): self.__dbData.Name = name
    def GetLeaderID(self): return self.__dbData.LeaderID
    def SetLeaderID(self, leaderID): self.__dbData.LeaderID = leaderID
    def GetLV(self): return self.__dbData.LV
    def SetLV(self, lv): self.__dbData.LV = lv
    def GetExp(self): return self.__dbData.Exp
    def SetExp(self, exp): self.__dbData.Exp = exp
    def GetJoinReview(self): return self.__dbData.JoinReview # ³ÉÔ±¼ÓÈëÊÇ·ñÐèÒªÉóºË£¬Ä¬ÈÏ0×Ô¶¯¼ÓÈë
    def SetJoinReview(self, joinReview): self.__dbData.JoinReview = joinReview
    def GetJoinLVMin(self): return self.__dbData.JoinLVMin
    def SetJoinLVMin(self, JoinLVMin): self.__dbData.JoinLVMin = JoinLVMin
    def GetBroadcast(self): return self.__dbData.Broadcast
    def SetBroadcast(self, broadcast):
        self.__dbData.Broadcast = broadcast
        self.__dbData.BroadcastLen = len(self.__dbData.Broadcast)
        return
    def GetFightPower(self): return self.__dbData.FightPower
    def GetFightPowerEx(self): return self.__dbData.FightPowerEx
    def GetFightPowerTotal(self):
        return self.__dbData.FightPowerEx * ChConfig.Def_PerPointValue + self.__dbData.FightPower
    def SetFightPowerTotal(self, fightPowerTotal):
        fpBef = self.GetFightPowerTotal()
        self.__dbData.FightPower = fightPowerTotal % ChConfig.Def_PerPointValue
        self.__dbData.FightPowerEx = fightPowerTotal / ChConfig.Def_PerPointValue
        fpAft = self.GetFightPowerTotal()
        if fpBef != fpAft:
            self.__familyMgr.OnFightPowerChange(self)
        return
    def GetEmblemID(self): return self.__dbData.EmblemID
    def SetEmblemID(self, emblemID): self.__dbData.EmblemID = emblemID
    def GetEmblemWord(self): return self.__dbData.EmblemWord
    def SetEmblemWord(self, emblemWord): self.__dbData.EmblemWord = emblemWord
    def GetExtra1(self): return self.__dbData.Extra1
    def SetExtra1(self, extra1): self.__dbData.Extra1 = extra1
    def GetExtra2(self): return self.__dbData.Extra2
    def SetExtra2(self, extra2): self.__dbData.Extra2 = extra2
    def GetExtra3(self): return self.__dbData.Extra3
    def SetExtra3(self, extra3): self.__dbData.Extra3 = extra3
    def GetExtra4(self): return self.__dbData.Extra4
    def SetExtra4(self, extra4): self.__dbData.Extra4 = extra4
    def GetExtra5(self): return self.__dbData.Extra5
    def SetExtra5(self, extra5): self.__dbData.Extra5 = extra5
    def GetBuffer(self): return self.__dbData.getBuffer()
    
    ## ------------------------------------------------
    def InitMemberInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        member = FamilyMem(dbData, self)
        playerID = member.GetPlayerID()
        if playerID in self.__memberDict:
            return
        self.__memberDict[playerID] = member
        self.__memberList.append(member)
        viewCache = PlayerViewCache.FindViewCache(playerID)
        member.SetOffTime(viewCache.GetOffTime() if viewCache else int(time.time()))
        self.__familyMgr.OnAddMember(self, playerID)
        return member
    
    def GetMemberIDList(self): return self.__memberDict.keys()
    
    def AddMember(self, playerID):
        member = None
        if playerID in self.__memberDict:
            member = self.__memberDict[playerID]
        else:
            dbData = DBStruct.tagDBFamilyMem()
            dbData.PlayerID = playerID
            dbData.FamilyID = self.GetID()
            dbData.JoinTime = int(time.time())
            member = self.InitMemberInstance(dbData)
            if not member and False:
                member = FamilyMem()
        self.RefrshFightPowerTotal()
        return member
    
    def DeleteMember(self, playerID):
        delMem = self.__memberDict.pop(playerID, None)
        if delMem in self.__memberList:
            self.__memberList.remove(delMem)
        self.RefrshFightPowerTotal()
        self.__familyMgr.OnDelMember(self, playerID)
        return delMem
    
    def FindMember(self, playerID):
        mem = None
        if playerID in self.__memberDict:
            mem = self.__memberDict[playerID]
        elif False:
            mem = FamilyMem()
        return mem
    
    def GetCount(self): return len(self.__memberList)
    def GetAt(self, index):
        mem = None
        if 0 <= index < len(self.__memberList):
            mem = self.__memberList[index]
        elif False:
            mem = FamilyMem()
        return mem
    
    def RefrshFightPowerTotal(self):
        ## Ë¢ÐÂ×ÜÕ½Á¦
        familyFightPowerTotal = 0
        for index in range(self.GetCount()):
            member = self.GetAt(index)
            if not member:
                continue
            familyFightPowerTotal += member.GetFightPowerTotal()
        self.SetFightPowerTotal(familyFightPowerTotal)
        return familyFightPowerTotal
    
    def GetReqJoinPlayerInfo(self):
        ## »ñÈ¡ÉêÇë¼ÓÈëµÄÍæ¼ÒÐÅÏ¢
        # @return: {playerID:ÉêÇëʱ¼ä´Á, ...}
        joinAction  = self.__actionMgr.GetFamilyAction(self.GetID(), ShareDefine.Def_ActionType_FamilyAdd)
        actionData = joinAction.GetOneAction(True)
        dataDict = actionData.GetUserDict()
        if "ReqJoin" not in dataDict:
            dataDict["ReqJoin"] = {}
        return dataDict["ReqJoin"]
    
    def AddReqJoinPlayerID(self, playerID):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        reqPlayerIDDict[playerID] = int(time.time()) # ÉêÇëʱ¼ä´Á
        self.__familyMgr.AddPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def DelReqJoinPlayerID(self, playerID):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        if playerID in reqPlayerIDDict:
            reqPlayerIDDict.pop(playerID)
        self.__familyMgr.DelPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def DelReqJoinPlayerAll(self):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        for playerID in reqPlayerIDDict.keys():
            reqPlayerIDDict.pop(playerID)
            self.__familyMgr.DelPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def OnDelete(self):
        for memID in self.__memberDict.keys():
            self.DeleteMember(memID)
        self.DelReqJoinPlayerAll()
        self.__actionMgr.ClearFamilyAction(self.GetID())
        return
    
#class FamilyViewBase():
#    ## ¹«»á»ù´¡ÐÅÏ¢£¬±¾·þ¿ç·þͨÓã¬Ò»°ãÓÃÓÚ±¾·þ¹«»áÐèÒªÓõĻù±¾ÐÅÏ¢£¬Èç²é¿´£¬·½±ã±¾·þ¿ÉÖ±½ÓÈ¡£¬ÓÉ¿ç·þͬ²½
#    
#    def __init__(self, familyID):
#        self._familyID = familyID
#        self._family = None
#        self._familyName = ""
#        self._serverID = 0
#        self._emblemID = 0
#        self._emblemWord = ""
#        return
#    
#    def SetFamily(self, family): self._family = family
#    
#    def GetID(self): return self._familyID
#    
#    # ÓÐÖµÒÔÉèÖõÄֵΪ׼-¿ç·þͬ²½¹ýÀ´µÄ£¬·ñÔòÒÔ±¾·þÒÑ´æÔڵĹ«»áÊý¾ÝΪ׼-¼´Î´»¥Í¨Ê±¼æÈÝÈ¡±¾·þ¹«»áÊý¾Ý
#    def GetName(self): return self._familyName if self._familyName else (self._family.GetName() if self._family else "")
#    def GetServerID(self): return self._serverID if self._serverID else (self._family.GetServerID() if self._family else 0)
#    def GetEmblemID(self): return self._emblemID if self._emblemID else (self._family.GetEmblemID() if self._family else 0)
#    def GetEmblemWord(self): return self._emblemWord if self._emblemWord else (self._family.GetEmblemWord() if self._family else "")
#    
#    def GetSyncData(self):
#        return [self.GetName(), self.GetServerID(), self.GetEmblemID(), self.GetEmblemWord()]
#    
#    def UpdSyncData(self, syncData):
#        ## ¸ù¾Ý¿ç·þͬ²½¹ýÀ´µÄ¸üÐÂ
#        self._familyName = syncData[0] if len(syncData) > 0 else self._familyName
#        self._serverID = syncData[1] if len(syncData) > 1 else self._serverID
#        self._emblemID = syncData[2] if len(syncData) > 2 else self._emblemID
#        self._emblemWord = syncData[3] if len(syncData) > 3 else self._emblemWord
#        return
    
class ZoneFamilyMgr():
    ## ¿ç·þ¹«»á»¥Í¨·ÖÇø£¬±¾·þµÄҲʹÓã¬Ä¬ÈÏ·ÖÇø0
    ## ¡¾×¢Òâ¡¿¿ç·þ·ÖÇøÖ»ÊÇÔÚÔ­¹«»áÊý¾ÝµÄ»ù´¡ÉϽøÐлã×ܹéÄÉ·ÖÇø£¬¼´Ê¹·ÖÇøÒì³£Ò²²»ÒªÓ°Ï칫»áÊý¾Ý£¬¿ÉÖظ´½øÐÐÐÞ¸ÄÅäÖÃÖØзÖÇø
    
    def __init__(self, zoneID=0):
        self.__familyMgr = DBDataMgr.GetFamilyMgr()
        self.__zoneID = zoneID # ±¾·þĬÈÏ·ÖÇø0£¬¼´Î´»¥Í¨µÄ·þÎñÆ÷
        self.__familyList = [] # ¹«»á¶ÔÏóÁÐ±í£¬¿É½øÐÐÅÅÐò [Family, ...]
        self.__familyIDDict = {} # ¹«»áID¶ÔÏó×Öµä,  {familyID:Family, ...}
        self.__familyNameDict = {} # ¹«»áÃû³Æ¶ÔÏó×Öµä,  {familyName:Family, ...}
        self.__zoneServerIDList = [] # ±¾·ÖÇøʵ¼ÊÒѾ­»¥Í¨µÄ¹«»á·þÎñÆ÷IDÁбí [serverID, ...]
        self.__familyIDRankDict = {} # ¹«»áÃû´Î×Öµä {familyID:rank, ...}
        self.__needSort = True
        
        ## ×¢Ò⣡עÒ⣡עÒ⣡ÔÝʱֻ´æ·ÖÇøµÄ¹«»áÁбí¹ÜÀí£¬ÆäËû·ÖÇøÏà¹ØµÄ»º´æÊý¾ÝÔݲ»Òª·ÅÕâÀï
        ## ÒòΪ·ÖÇøÅäÖÃÖضÁ±ä¸üºó»á±»ÖØÖÿÉÄܵ¼Ö¶ªÊ§£¬ÈçÐèÒª´æ´¢ÆäËûÊý¾ÝÔÙÁíÐд¦Àí
        return
    
    def GetZoneID(self): return self.__zoneID
    
    def SetSort(self): self.__needSort = True # ÉèÖÃÐèÒªÅÅÐò
    
    def Sort(self, checkSort=False):
        ''' ĬÈÏÅÅÐòµ¹Ðò£¬°´  ÏÉÃË×ÜÕ½Á¦ -> ÏÉÃ˵ȼ¶
        @param checkSort: ÊÇ·ñ¼ì²éÐèÒªÅÅÐò£¬Èç¹ûÐèÒªÅÅÐò²Å»áÅÅÐò£¬ÉèÖÃTrueʱÔòÇ¿ÖÆÅÅÐò²»¼ì²é
        '''
        if checkSort and not self.__needSort:
            return
        self.__familyList.sort(key=lambda f: (f.GetFightPowerTotal(), f.GetLV()), reverse=True)
        self.__familyIDRankDict = {}
        self.__needSort = False
        return
    
    def AddFamilyToZone(self, family):
        ## ½«Ä³¸ö¹«»á·ÖÅä¸ø¸Ã·ÖÇø
        if not family:
            return
        familyID = family.GetID()
        if familyID in self.__familyIDDict:
            return
        self.__familyIDDict[familyID] = family
        
        familyServerID = family.GetServerID()
        familyName = family.GetName()
        # ¹æ¶¨Ïàͬ·ÖÇøÃû×ÖΨһ£¬ÈçÖØÃû£¬Ç¿ÖÆÐÞ¸ÄΪΨһµÄ£»ºÏ·þÊý¾ÝºÏ²¢¡¢Ê״λ¥Í¨´«Êý¾ÝµÈ¾ùÖ§³Ö×Ô¶¯¸ÄÃû
        if familyName in self.__familyNameDict:
            for doCnt in range(1, 1000):
                fixName = "%s%s" % (familyName, doCnt) # Ç¿ÖƼӸö±àºÅ
                if fixName not in self.__familyNameDict:
                    familyName = fixName
                    break
            family.SetName(familyName)
            family.SetExtra1(0) # ÖØÖøÄÃûCD
        self.__familyNameDict[familyName] = family
        
        if family not in self.__familyList:
            self.__familyList.append(family)
            self.__familyIDRankDict = {} # й«»á¼ÓÈëʱÖØÖÃ
            
        if familyServerID not in self.__zoneServerIDList:
            self.__zoneServerIDList.append(familyServerID)
            
        self.__needSort = True
        self.__familyMgr.OnAddToZone(family, self.__zoneID)
        return
    
    def DelZoneFamily(self, familyID):
        family = self.__familyIDDict.pop(familyID, None)
        if not family:
            return
        if family in self.__familyList:
            self.__familyList.remove(family)
        self.__familyNameDict.pop(family.GetName(), None)
        self.__familyIDRankDict.pop(familyID, None)
        self.__needSort = True
        return
    
    def GetZoneServerIDList(self): return self.__zoneServerIDList
    
    def FindFamily(self, familyID):
        family = None
        if familyID and familyID in self.__familyIDDict:
            family = self.__familyIDDict[familyID]
        elif False:
            family = Family()
        return family
    
    def FindFamilyByName(self, familyName):
        family = None
        if familyName in self.__familyNameDict:
            family = self.__familyNameDict[familyName]
        elif False:
            family = Family()
        return family
    
    def GetCount(self): return len(self.__familyList)
    def GetAt(self, index):
        family = None
        if 0 <= index < len(self.__familyList):
            family = self.__familyList[index]
        elif False:
            family = Family()
        return family
    
    def GetFamilyRank(self, familyID):
        ## »ñÈ¡¹«»áIDËùÔÚÅÅÃû
        # @return: 0-δÉÏ°ñ£» >0-Ãû´Î
        if not familyID:
            return 0
        if not self.__familyIDRankDict:
            self.__familyIDRankDict = {}
            for rank, family in enumerate(self.__familyList, 1):
                self.__familyIDRankDict[family.GetID()] = rank
        if familyID not in self.__familyIDRankDict:
            return 0
        return self.__familyIDRankDict[familyID]
    
class FamilyMgr():
    ''' ËùÓзÖÇøµÄ¹«»á×ܹÜÀí£¬±¾·þ¡¢¿ç·þͨÓã¬zoneIDΪ0ʱĬÈÏÊDZ¾·þµÄ·Ç¿ç·þ»¥Í¨¹«»á
    '''
    
    def __init__(self):
        
        ## ----------------------- ¹«»áÊý¾Ý·þÎñÆ÷µÄÐÅÏ¢£¬È硾δ»¥Í¨ÓÎÏ··þ¡¿ »ò ¡¾¿ç·þ¡¿ ------------------------
        # ±¾·þÎñÆ÷Êý¾Ý£¬¿ÉÄÜÊÇÓÎÏ··þ±¾·þ »ò ¿ç·þ»¥Í¨Êý¾Ý
        self.__familyIDDict = {} # ¹«»áID¶ÔÏó×Öµä,  {familyID:Family, ...}
        self.__playerFamilyIDDict = {} # Íæ¼ÒËùÊô¹«»áID×Öµä {playerID:familyID, ...}
        self.__playerReqJoinDict = {} # Íæ¼ÒÉêÇë¼ÓÈëÏÉÃËÁбí {playerID:[familyID, ...], ...}
        self.__actionMgr = FamilyActionMgr()
        
        # ±¾·þÊý¾Ý·ÖÇø¹ÜÀí£¬ÓÎÏ··þÉÐδδ·ÖÇøµÄĬÈÏʹÓ÷ÖÇø0£¬ÒòΪֻ¹ÜÀí±¾·þ¹«»áÊý¾Ý£¬¹Ê²»ÓÃÔÙ°´crossServerIDÇø·Ö£¬Ä¬È϶¼ÊôÓÚ±¾·þµÄserverID
        # ·ÖÇø¿ÉÄÜËæʱ±»ÖØÖÃÖØзÖÅ䣬¹ÊÈçÓÐÐèÒª³Ö¾Ã»¯µÄÂß¼­Êý¾ÝÐèÒªÁíÐд¦Àí£¬»òÔÚÖØÖúó¸´ÖÆËùÐè³Ö¾Ã»¯µÄÊý¾Ý£¬ÔÝʱ²»Óã¬Ö®ºóÓÐÐèÒªÔÙ´¦Àí
        self.__zoneFamilyMgrDict = {} # ·ÖÇø¶ÔÓ¦¹«»á·ÖÇø¹ÜÀíÆ÷ {zoneID:ZoneFamilyMgr(), ...}
        self.__familyIDZoneIDDict = {} # ¹«»áID¶ÔÓ¦ËùÊô·ÖÇø {familyID:zoneID, ...}
        
        ## ------------------------ ¡¾ËùÓзþÎñÆ÷¡¿»áÓеÄÐÅÏ¢£¬ÓÉ¿ç·þÖÐÐÄ»ò¿ç·þͬ²½ ------------------------
        # ·ÖÇøÅäÖÃ˵Ã÷£º
        # 1. Æô¶¯Ê±ÓÉ¿ç·þÖÐÐijõ²½ÑéÖ¤ÅäÖúÏÀíÐÔ£¬Èç·þÎñÆ÷·¶Î§Óн»²æ¡¢²ð·ÖµÈ£¬ÑéÖ¤²»Í¨¹ý²»»á֪ͨ£¬ÇÒÓʼþ֪ͨÔËά
        # 2. ¿ç·þÖÐÐÄÑé֤ͨ¹ýºó¹ã²¥¸øËùÓпç·þ·þÎñÆ÷£¬¿ç·þ·þÎñÆ÷½øÒ»²½ÑéÖ¤ÊÇ·ñÓÐδ·ÖÅäµÄ¹«»á£¬ÓÐÔòÑéÖ¤²»Í¨¹ý£¬ÇÒÓʼþ֪ͨÔËά
        # 3. ¿ç·þÖÐÐÄ¡¢¿ç·þ¾ùÑé֤ͨ¹ýºó£¬»á°´ÅäÖõķÖÇø³õʼ»¯¸÷·ÖÇø¹«»á¹ÜÀí£¬È»ºóͬ²½¸ø¸÷×ԵķÖÇøÓÎÏ··þ
        # 4. Èȸü·ÖÇøÅäÖÃʱ£¬Ö»¸üпç·þÖÐÐļ´¿É£¬ÓÉ¿ç·þÖÐÐÄ·¢ÆðÑéÖ¤£¬Í¬ÑùÖ´ÐÐÁ÷³Ì 1~3£¬ÑéÖ¤²»Í¨¹ýµÄ²»»á¸üÐÂÅäÖ㬱£ÁôÔ­·ÖÇøÅäÖÃ
        # 5. Èȸü·ÖÇøÑé֤ͨ¹ýºó£¬»áÖØÐÂÉú³É¹«»á·ÖÇø£¬Èȸü½ö¶Ô²»ÐèÒª²»¸Ä±ä¹«»áÊý¾ÝËùÔÚ·þÎñÆ÷ʱÓÐЧ
        # 6. ÈçÐè¸Ä±äÒÑ»¥Í¨¹«»áÊý¾ÝËùÔÚ¿ç·þ£¬ÐèÍ£·þά»¤ÏȽøÐпç·þÊý¾ÝºÏ²¢ºó£¬ÖØÆô·þÎñÆ÷
        # ¡¾×¢¡¿ÓÎÏ··þÊ״οç·þ£¬¸ù¾ÝÊÕµ½µÄ»¥Í¨ÅäÖýøÐÐÑéÖ¤ÊÇ·ñ¿ªÊ¼¿ç·þ£¬¿ªÊ¼ºóͬ²½Êý¾Ý¸øËùÊô¿ç·þ£¬¿ÉÖظ´Í¬²½Ö±µ½³É¹¦£¬·ñÔò»¹ÊDZ£³ÖʹÓñ¾·þ¹«»áÊý¾Ý
        self.__crossZoneCfgDict = {} # ¿ç·þ»¥Í¨·ÖÇøÅäÖà {crossServerID:{zoneID:[»¥Í¨·þÎñÆ÷ID·¶Î§Áбí], ...}, ...}£¬ÓÉ¿ç·þÖÐÐÄͬ²½
        
        ## ------------------------ ¡¾ÓÎÏ··þ¡¿×¨ÓÐÐÅÏ¢£¬Ò»°ãÓÉËùÊô»¥Í¨¿ç·þÊý¾Ý·þͬ²½ ----------------------
        # »¥Í¨¹«»á»ù±¾ÐÅÏ¢ - ²é¿´Íæ¼ÒÒ³ÃæÐèÒª¿´µ½µÄËùÊô¹«»á×î¼òµ¥µÄÐÅÏ¢£¬Ò»°ãÖ»ÓÐÓÎÏ··þÓõ½
        #self.__familyViewBaseDict = {} # ¹«»áID¶ÔÓ¦»ù´¡²é¿´ÐÅÏ¢ {familyID:FamilyViewBase, ...}
        self.__curZoneServerIDList = [] # µ±Ç°ÓÎÏ··þÖ÷·þËùÊô»¥Í¨·ÖÇøʵ¼ÊÒѾ­»¥Í¨µÄ·þÎñÆ÷IDÁÐ±í£¬Í¬²½¸øÇ°¶ËµÄ
        self.__curCrossServerID = 0 # µ±Ç°ÓÎÏ··þÖ÷·þ¹«»áËùÊô¿ç·þID
        self.__curZoneID = 0 # µ±Ç°ÓÎÏ··þÖ÷·þËùÊô»¥Í¨·ÖÇøID
        ## ¡¾²»ÔÊÐí²»Í¬»¥Í¨·ÖÇøµÄºÏ·þ¡¿
        return
    
    def InitFamilyInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        family = Family(dbData)
        familyID = family.GetID()
        if familyID in self.__familyIDDict:
            return self.__familyIDDict[familyID]
        self.__familyIDDict[familyID] = family
        return family
    
    def AddFamily(self, familyName, serverID, familyID=None):
        ## ´´½¨ÐÂÏÉÃË
        newFamily = None
        if not familyName or not serverID:
            GameWorld.ErrLog("´´½¨¹«»á²ÎÊýÒì³££¬ÎÞ·¨´´½¨! serverID=%s" % serverID)
            return newFamily
        zoneID = self.GetZoneIDInThisServer(serverID)
        if zoneID < 0:
            GameWorld.ErrLog("·þÎñÆ÷ID´´½¨µÄ¹«»á²»ÊôÓÚ±¾·þ¹ÜÀí£¬ÎÞ·¨´´½¨! serverID=%s" % serverID)
            return newFamily
        if familyID == None:
            familyID = PyMongoMain.GetUserCtrlDB().GetNewFamilyID()
            if familyID <= 0:
                GameWorld.ErrLog("´´½¨¹«»áʱÉú³ÉÐÂIDÒì³£!")
                return newFamily
        if familyID in self.__familyIDDict:
            GameWorld.ErrLog("´´½¨¹«»áʱIDÒÑ´æÔÚ! familyID=%s" % familyID)
            return newFamily
        # Ãû×Öͨ¹ý·ÖÇø¹ÜÀíÑéÖ¤²¢×Ô¶¯ÐÞ¸ÄΪ²»ÖØÃû
        #if familyName in self.__familyNameDict:
        #    GameWorld.ErrLog("´´½¨ÏÉÃËʱÃû³ÆÒÑ´æÔÚ! familyName=%s" % familyName)
        #    return newFamily
        #if len(self.__familyList) >= FamilyUpperLimitCount:
        #    GameWorld.ErrLog("µ¥·þÏÞÖÆ´´½¨ÏÉÃËÊýÒÑ´ïÉÏÏÞ!")
        #    return newFamily
        
        dbData = DBStruct.tagDBFamily()
        dbData.ID = familyID
        dbData.Name = familyName
        dbData.ServerID = serverID
        dbData.CreateTime = int(time.time())
        
        newFamily = self.InitFamilyInstance(dbData)
        if not newFamily and False: # ²»Ö´ÐУ¬ÎªÁË´úÂëÌáʾ
            newFamily = Family()
            
        # Ìí¼Óµ½ËùÊô·ÖÇø
        zoneMgr = self.GetZoneFamilyMgr(zoneID)
        zoneMgr.AddFamilyToZone(newFamily)
        
        return newFamily
    
    def OnFightPowerChange(self, family):
        zoneMgr = self.GetZoneFamilyMgrByFamilyID(family.GetID())
        if not zoneMgr:
            return
        zoneMgr.SetSort()
        return
    
    def OnAddToZone(self, family, zoneID):
        familyID = family.GetID()
        self.__familyIDZoneIDDict[familyID] = zoneID
        return
    
    def OnAddMember(self, family, playerID):
        self.__playerFamilyIDDict[playerID] = family.GetID()
        return
    
    def OnDelMember(self, family, playerID):
        self.__playerFamilyIDDict.pop(playerID, None)
        return
    
    def GetFamilyIDList(self): return self.__familyIDDict.keys()
    
    def FindFamily(self, familyID):
        family = None
        if familyID and familyID in self.__familyIDDict:
            family = self.__familyIDDict[familyID]
        elif False:
            family = Family()
        return family
    
    def DelFamily(self, familyID, isFreeID=True):
        family = self.FindFamily(familyID)
        self.__familyIDDict.pop(familyID, None)
        
        # ͬ²½´Ó·ÖÇøÖÐɾ³ý
        if familyID in self.__familyIDZoneIDDict:
            zoneID = self.__familyIDZoneIDDict.get(familyID)
            zoneMgr = self.GetZoneFamilyMgr(zoneID)
            zoneMgr.DelZoneFamily(familyID)
            
        # ×îºóɾ³ý×ÔÉí
        if family:
            family.OnDelete()
        if isFreeID and familyID >= ShareDefine.RealFamilyIDStart:
            PyMongoMain.GetUserCtrlDB().FreeFamilyID(familyID) # ¹é»¹ÏÉÃËID£¬Öظ´Ê¹ÓÃ
        return family
    
    def DelAllFamily(self):
        for familyID in self.__familyIDDict.keys():
            self.DelFamily(familyID)
        return
    
    def GetFamilyActionMgr(self): return self.__actionMgr
    
    def __afterLoadDBFamilyData(self):
        self.__playerFamilyIDDict = {}
        self.__playerReqJoinDict = {}
        for family in self.__familyIDDict.values():
            familyID = family.GetID()
            family.RefrshFightPowerTotal()
            
            for index in range(family.GetCount()):
                member = family.GetAt(index)
                self.__playerFamilyIDDict[member.GetPlayerID()] = familyID
                
            reqPlayerIDDict = family.GetReqJoinPlayerInfo()
            #keyÇ¿ÖÆתΪint£¬ÏßÉϵÄÊÇ×Ö·û´®£¬×öÊý¾Ý¼æÈÝ
            for reqIDStr, v in reqPlayerIDDict.items():
                reqID = int(reqIDStr)
                reqPlayerIDDict.pop(reqIDStr, None)
                reqPlayerIDDict[reqID] = v
                if reqID not in self.__playerReqJoinDict:
                    self.__playerReqJoinDict[reqID] = []
                reqFamilyIDList = self.__playerReqJoinDict[reqID]
                if familyID not in reqFamilyIDList:
                    reqFamilyIDList.append(familyID)
                    
        return
    
    def GetPlayerFamilyID(self, playerID):
        ## »ñÈ¡Íæ¼ÒIDµ±Ç°ËùÔڵĹ«»áID
        return self.__playerFamilyIDDict.get(playerID, 0)
    
    def GetPlayerReqJoinFamilyIDList(self, playerID):
        ## »ñÈ¡Íæ¼ÒÉêÇë¼ÓÈëµÄÏÉÃËIDÁбí
        if playerID not in self.__playerReqJoinDict:
            self.__playerReqJoinDict[playerID] = []
        return self.__playerReqJoinDict[playerID]
    
    def AddPlayerReqJoinFamilyID(self, playerID, familyID):
        ## Ìí¼ÓÍæ¼ÒÉêÇë¼ÓÈëÄ¿±êÏÉÃ˼Ǽ
        # @return: ÊÇ·ñÓÐÔö¼Ó¼Ç¼
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        if familyID not in reqFamilyIDList:
            reqFamilyIDList.append(familyID)
            return True
        return False
    
    def DelPlayerReqJoinFamilyID(self, playerID, familyID):
        ## ɾ³ýÍæ¼ÒÉêÇë¼ÓÈëÄ¿±êÏÉÃ˼Ǽ
        # @return: ÊÇ·ñÓÐɾ³ý¼Ç¼
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        if familyID in reqFamilyIDList:
            reqFamilyIDList.remove(familyID)
            return True
        return False
    
    def DelPlayerReqJoinFamilyIDAll(self, playerID):
        ## ɾ³ýÍæ¼ÒËùÓеÄÉêÇë¼ÓÈëÏÉÃ˼Ǽ
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        for familyID in reqFamilyIDList[::-1]:
            family = self.FindFamily(familyID)
            if not family:
                continue
            family.DelReqJoinPlayerID(playerID)
        return
    
    def GetCrossZoneCfgDict(self): return self.__crossZoneCfgDict # {crossServerID:{zoneID:[»¥Í¨·þÎñÆ÷ID·¶Î§Áбí], ...}, ...}
    def SetCrossZoneCfgDict(self, crossZoneCfgDict): self.__crossZoneCfgDict = crossZoneCfgDict # Ö±½ÓÉèÖõIJ»×ö¸üмì²âÂß¼­£¬Ò»°ãÓÎÏ··þÓÃ
    def UpdCrossZoneCfgDict(self, updCrossZoneCfgDict):
        ## ¸üзÖÇøÅäÖã¬ÖØÖ÷ÖÇø£¬ÖØзÖÅä
        ## @return: ±¾¿ç·þÊÇ·ñ³É¹¦¸üзÖÇø£¬ÑéÖ¤²»Í¨¹ýµÄ»°²»»áÖØÖ㬱£ÁôÔ­·ÖÇø
        GameWorld.Log("¿ç·þ¹«»á»¥Í¨ÅäÖøüÐÂ! updCrossZoneCfgDict=%s" % updCrossZoneCfgDict)
        if not CheckCrossZoneCfg(self.__crossZoneCfgDict, updCrossZoneCfgDict):
            return
        
        crossServerID = GameWorld.GetGameWorld().GetServerID()
        if crossServerID not in updCrossZoneCfgDict:
            GameWorld.Log("±¾¿ç·þδ·ÖÅä·ÖÇøµÄÖ»¸üÐÂÅäÖü´¿É!")
            self.__crossZoneCfgDict = updCrossZoneCfgDict
            return
        zoneDict = updCrossZoneCfgDict[crossServerID]
        
        # ´æÔÚûÓзÖÅäµÄ¹«»á£¬²»Ó¦¸Ã´¦Àí£¬¿ÉÄÜ·ÖÇøÅäÖÃÓëʵ¼ÊÊý¾Ý²»Ò»Ö£¬Ò»°ã·¢ÉúÔÚµ÷Õû·ÖÇøʱ£¬Óʼþ֪ͨÔËά
        familyZoneDict = {}
        noZoneServerIDList = [] # ûÓÐËùÊô·ÖÇøµÄ·þÎñÆ÷IDÁбí
        for family in self.__familyIDDict.values():
            familyID = family.GetID()
            familyServerID = family.GetServerID()
            zoneID = 0
            for zID, serverIDRangeList in zoneDict.items():
                if GameWorld.CheckServerIDInList(familyServerID, serverIDRangeList):
                    zoneID = zID
                    break
            if not zoneID:
                if familyServerID not in noZoneServerIDList:
                    noZoneServerIDList.append(familyServerID)
            else:
                familyZoneDict[familyID] = zoneID
                
        if noZoneServerIDList:
            GameWorld.SendGameErrorEx("FamilyCrossZoneCfgError", "noZoneServerIDList=%s" % noZoneServerIDList)
            return
        
        # ¸üÐÂÅäÖá¢ÖØÖá¢ÖØзÖÇø
        self.__crossZoneCfgDict = updCrossZoneCfgDict
        self.__zoneFamilyMgrDict = {}
        self.__familyIDZoneIDDict = {}
        
        # ÖØгõʼ»¯±¾·þ¹ÜÀíµÄ·ÖÇø
        zoneDict = self.__crossZoneCfgDict[crossServerID]
        GameWorld.Log("±¾¿ç·þÖØÖù«»á»¥Í¨·ÖÇø! crossServerID=%s,zoneDict=%s" % (crossServerID, zoneDict))
        for zoneID in zoneDict.keys():
            self.GetZoneFamilyMgr(zoneID)
        GameWorld.Log("GetZoneIDListThisServer=%s" % self.GetZoneIDListThisServer())
        
        # ÖØн«±¾·þ¹«»áÊý¾Ý·ÖÅäµ½ËùÊô·ÖÇø
        for family in self.__familyIDDict.values():
            familyID = family.GetID()
            zoneID = familyZoneDict.get(familyID, 0) # ÀíÂÛÉϲ»¿ÉÄÜÔÙΪ0£¬ÒòΪÓÐ0ʱ noZoneServerIDList ÑéÖ¤²»»áͨ¹ý
            zoneMgr = self.GetZoneFamilyMgr(zoneID)
            zoneMgr.AddFamilyToZone(family)
            
        return True
    
    def __setFamilyToDefaultZone(self):
        ## ½«±¾·þ¹«»áÈ«²¿¹éµ½Ä¬ÈÏ·ÖÇø0£¬½öÓÎÏ··þʹÓÃ
        self.__zoneFamilyMgrDict = {}
        self.__familyIDZoneIDDict = {}
        zoneID = 0
        zoneMgr = self.GetZoneFamilyMgr(zoneID)
        for family in self.__familyIDDict.values():
            zoneMgr.AddFamilyToZone(family)
        return
    
    def GetZoneIDInThisServer(self, serverID=None):
        '''»ñÈ¡·þÎñÆ÷IDÔÚ±¾¹«»áÊý¾Ý·þÎñÆ÷ÖÐËùÊôµÄ·ÖÇøID£¬
        @return: zoneID -2-»ò´«ÊäÊý¾ÝÖУ»-1-·ÖÇø²»ÔÚ±¾·þÎñÆ÷£»0-δ»¥Í¨Ä¬ÈÏ·ÖÇø0£»>0-ÔÚ±¾·þÊý¾ÝÖÐËùÔÚ·ÖÇøID
        '''
        curServerID = GameWorld.GetGameWorld().GetServerID()
        if not serverID:
            serverID = curServerID
        zoneID = -1
        serverType = GameWorld.GetServerType()
        if serverType == ShareDefine.serverType_Main:
            if IsFamilyCrossInTransData():
                zoneID = -2
            elif not IsFamilyCross():
                zoneID = 0 # ±¾·þδ¿ç·þ»¥Í¨µÄĬÈÏ·ÖÇø0
        elif GameWorld.IsCrossServer() and curServerID in self.__crossZoneCfgDict:
            # ¿ç·þ·þÎñÆ÷²»ÊÊÓà __zoneFamilyMgr ÅжÏÊÇÒòΪÈç¹û³öÏÖij¸ö·þÎñÆ÷IDµÄËùÓй«»á¶¼±»É¾³ýÁË£¬ÖØÆô·þÎñÆ÷µÄʱºò´Ó·ÖÇø¹ÜÀíÖпÉÄÜÕÒ²»µ½¸Ã·þÎñÆ÷ID
            # ËùÒÔʹÓÃÒÑÑéÖ¤¹ýµÄ»¥Í¨ÅäÖü´¿É£¬»¥Í¨ÅäÖÃÒѾ­ÑéÖ¤¹ýºÏÀíÐÔ£¬¿ÉÒÔÖ±½ÓÓÃ
            zoneDict = self.__crossZoneCfgDict[curServerID]
            for zID, serverIDRangeList in zoneDict.items():
                if GameWorld.CheckServerIDInList(serverID, serverIDRangeList):
                    zoneID = zID
                    break
        return zoneID
    
    def GetZoneIDListThisServer(self): return self.__zoneFamilyMgrDict.keys() # ±¾·þ¹ÜÀíµÄ·ÖÇø
    
    def GetFamilyZoneID(self, familyID): return self.__familyIDZoneIDDict.get(familyID, -1) # -1-δÕÒµ½ËùÊô·ÖÇø£»>=0-ËùÊô·ÖÇø
    
    def GetZoneFamilyMgrByFamilyID(self, familyID):
        ## »ñÈ¡¹«»áIDÔÚ±¾·þÊý¾ÝËùÊô·ÖÇø¹ÜÀíÆ÷
        # @return: ¿ÉÄÜ·µ»ØNone - ¹«»áÊý¾Ý²»ÔÚ±¾·þ
        zoneID = -1
        if familyID in self.__familyIDZoneIDDict:
            zoneID = self.__familyIDZoneIDDict[familyID]
        zoneMgr = None
        if zoneID >= 0:
            zoneMgr = self.GetZoneFamilyMgr(zoneID)
        return zoneMgr
    
    def GetZoneFamilyMgr(self, zoneID=0):
        ## »ñȡij¸ö·ÖÇøµÄ¹«»á¹ÜÀíÆ÷
        # @param zoneID: δ»¥Í¨µÄ·þÎñÆ÷ĬÈÏʹÓÃ0£¬Ê¹Ó÷½·¨Ò»ÖÂ
        zoneMgr = None
        if zoneID in self.__zoneFamilyMgrDict:
            zoneMgr = self.__zoneFamilyMgrDict[zoneID]
        else:
            zoneMgr = ZoneFamilyMgr(zoneID)
            self.__zoneFamilyMgrDict[zoneID] = zoneMgr
        return zoneMgr
    
#    def GetFamilyViewBase(self, familyID):
#        ## »¥Í¨¹«»á»ù±¾ÐÅÏ¢£¬±¾·þ¿ç·þͨÓã¬Êµ¼ÊµÄ¹«»áÍêÕûÊý¾Ý¿ÉÄܲ»ÔÚ±¾·þ
#        vBase = None
#        if familyID in self.__familyViewBaseDict:
#            vBase = self.__familyViewBaseDict[familyID]
#        else:
#            vBase = FamilyViewBase(familyID)
#            self.__familyViewBaseDict[familyID] = vBase
#        vBase.SetFamily(self.FindFamily(familyID))
#        return vBase
    
    def GetCurCrossServerID(self):
        ## ÓÎÏ··þ»ñÈ¡ËùÊôµÄ¿ç·þ»¥Í¨·þÎñÆ÷ID£¬Ò»¸öÓÎÏ··þÖ÷·þÖ»ÔÊÐíÒ»¸ö»¥Í¨·ÖÇø£¬²»Í¬·ÖÇøµÄ²»ÄܺϷþ
        # @return: -2-´«ÊäÊý¾ÝÖУ»-1-·ÇÓÎÏ··þ»òûÓÐÕýÈ·µÄ¿ç·þID£»0-δ»¥Í¨£»>0-»¥Í¨µÄÄ¿±ê¿ç·þID
        serverType = GameWorld.GetServerType()
        if serverType != ShareDefine.serverType_Main:
            return -1
        
        if IsFamilyCrossInTransData():
            return -2
        
        # δ»¥Í¨
        if not IsFamilyCross():
            return 0
        
        if self.__curCrossServerID:
            return self.__curCrossServerID
        
        curServerID = GameWorld.GetGameWorld().GetServerID()
        for crossServerID, zoneDict in self.__crossZoneCfgDict.items():
            for serverIDRangeList in zoneDict.values():
                if GameWorld.CheckServerIDInList(curServerID, serverIDRangeList):
                    return crossServerID
                
        return -1
    
    def SetCurCrossServerID(self, curCrossServerID): self.__curCrossServerID = curCrossServerID # Ö±½ÓÉèÖõÄÓÎÏ··þרÓÃ
    def GetCurZoneID(self): # ±¾ÓÎÏ··þÖ÷·þËùÊô»¥Í¨·ÖÇøID
        return 0 if not IsFamilyCross() else self.__curZoneID
    def SetCurZoneID(self, curZoneID): self.__curZoneID = curZoneID # Ö±½ÓÉèÖõÄÓÎÏ··þרÓÃ
    def GetCurZoneServerIDList(self): return self.__curZoneServerIDList # ±¾ÓÎÏ··þÖ÷·þʵ¼ÊÒÑ»¥Í¨µÄ·þÎñÆ÷IDÁбí
    def SetCurZoneServerIDList(self, curZoneServerIDList): self.__curZoneServerIDList = curZoneServerIDList # Ö±½ÓÉèÖõÄÓÎÏ··þרÓÃ
    
    # ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
    def GetSaveData(self, cntDict=None):
        
        familyDataCnt, familySavaData = 0, ""
        membreDataCnt, memberSavaData = 0, ""
        actionDataCnt, actionSavaData = 0, ""
        
        for family in self.__familyIDDict.values():
            
            familyID = family.GetID()
            familySavaData += family.GetBuffer()
            familyDataCnt += 1
            
            for memIndex in range(family.GetCount()):
                member = family.GetAt(memIndex)
                memberSavaData += member.GetBuffer()
                membreDataCnt += 1
                
            for actionType in self.__actionMgr.GetActionTypeList(familyID):
                action = self.__actionMgr.GetFamilyAction(familyID, actionType)
                for aIndex in range(action.Count()):
                    actionData = action.At(aIndex)
                    actionSavaData += actionData.GetBuffer()
                    actionDataCnt += 1
                    
        saveData = ""
        
        saveData += CommFunc.WriteDWORD("", familyDataCnt) + familySavaData
        GameWorld.Log("Save DBFamily count :%s len=%s" % (familyDataCnt, len(familySavaData)))
        
        saveData += CommFunc.WriteDWORD("", membreDataCnt) + memberSavaData
        GameWorld.Log("Save DBFamilyMem count :%s len=%s" % (membreDataCnt, len(memberSavaData)))
        
        saveData += CommFunc.WriteDWORD("", actionDataCnt) + actionSavaData
        GameWorld.Log("Save DBFamilyAction count :%s len=%s" % (actionDataCnt, len(actionSavaData)))
        if isinstance(cntDict, dict):
            cntDict.update({"familyDataCnt":familyDataCnt, "membreDataCnt":membreDataCnt, "actionDataCnt":actionDataCnt})
        return saveData
    
    # ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
    def LoadPyGameData(self, datas, pos, dataslen):
        # ¹«»á
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamily count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamily()
            pos += dbData.readData(datas, pos, dataslen)
            self.InitFamilyInstance(dbData)
            
        # ³ÉÔ±
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamilyMem count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamilyMem()
            pos += dbData.readData(datas, pos, dataslen)
            
            familyID = dbData.FamilyID
            family = self.FindFamily(familyID)
            if not family:
                continue
            family.InitMemberInstance(dbData)
            
        # ÐÐΪ
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamilyAction count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamilyAction()
            pos += dbData.readData(datas, pos, dataslen)
            
            familyID = dbData.FamilyID
            actionType = dbData.ActionType
            
            family = self.FindFamily(familyID)
            if not family:
                continue
            action = self.__actionMgr.GetFamilyAction(familyID, actionType)
            action.InitActionInstance(dbData)
            
        self.__afterLoadDBFamilyData()
        
        PyMongoMain.GetUserCtrlDB().OnFamilyIDInit(self.__familyIDDict.keys())
        
        serverType = GameWorld.GetServerType()
        if serverType == ShareDefine.serverType_CrossCenter:
            self.UpdCrossZoneCfgDict(LoadZoneCfg())
        elif serverType == ShareDefine.serverType_Main:
            self.__setFamilyToDefaultZone() # ÓÎÏ··þ±¾·þµÄÊý¾ÝÎÞÂÛÓÐûÓпç·þÁ˶¼Í¬ÒâÉèÖõ½Ä¬ÈÏ·ÖÇø
        return pos
    
def LoadZoneCfg():
    crossZoneCfgDict = {}
    appID = GameWorld.GetAppID()
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetFamilyCrossCount()):
        ipyData = ipyDataMgr.GetFamilyCrossByIndex(index)
        if ipyData.GetAppID() != appID:
            continue
        crossServerID = ipyData.GetCrossServerID()
        zoneID = ipyData.GetZoneID()
        if crossServerID not in crossZoneCfgDict:
            crossZoneCfgDict[crossServerID] = {}
        zoneDict = crossZoneCfgDict[crossServerID]
        zoneDict[zoneID] = [] + ipyData.GetServerIDList()
    GameWorld.Log("¿ç·þ¹«»á·ÖÇøÅäÖüÓÔØ: appID=%s,%s" % (appID, crossZoneCfgDict))
    return crossZoneCfgDict

def CheckCrossZoneCfg(curCrossZoneCfgDict, updCrossZoneCfgDict):
    # ¼ì²é´ý¸üеķÖÇøÅäÖÃÊÇ·ñ·ûºÏ¹æÔò£¬²»·ûºÏµÄ»°±£ÁôÔ­ÅäÖ㬲»¸üУ¬´ýÀ©Õ¹
    
    if curCrossZoneCfgDict == updCrossZoneCfgDict:
        GameWorld.Log("¿ç·þ¹«»á»¥Í¨·ÖÇøÅäÖò»±ä²»´¦Àí")
        return
    
    # ÑéÖ¤ÅäÖã¬ÊÇ·ñÓн»²æ¡¢²ð·Ö£¬²¢Óʼþ֪ͨÔËά£¬´ýÀ©Õ¹£¬¹¦ÄÜÍêÕûÐÔÓÅÏÈ
    #GameWorld.SendGameErrorEx("FamilyCrossZoneCfgError", "noZoneServerIDList=%s" % noZoneServerIDList)
    
    return True

def OnReloadConfig():
    '''ÖضÁÅäÖÃÑéÖ¤Ð޸ĺóµÄÅäÖÃÊÇ·ñ·ûºÏ¹æ¶¨£¬²»·ûºÏµÄ»°£¬»¹ÊÇʹÓþÉÅäÖõķ¶Î§£¬²¢Óʼþ֪ͨÔËά
    ¹«»á·ÖÇøÅäÖÃͬ²½¹æÔò£º ÓÉ¿ç·þÖÐÐļÓÔØÅäÖà  -> Ñé֤ͨ¹ýºó·¢¸øËùÓпç·þ -> ¿ç·þÑé֤ͨ¹ýºó·¢¸øËù¹ÜϽµÄ·ÖÇøËùÓÐÓÎÏ··þÎñÆ÷
    '''
    
    if GameWorld.IsCrossCenter():
        crossZoneCfgDict = LoadZoneCfg()
        if not crossZoneCfgDict or not DBDataMgr.GetFamilyMgr().UpdCrossZoneCfgDict(crossZoneCfgDict):
            return
        Sync_CenterToCross_FamilyCrossCfg()
        Sync_CrossToServer_FamilyInfo()
    return

def Sync_CenterToCross_FamilyInfo(serverType, serverID):
    ## ¿ç·þÖÐÐÄͬ²½¸ø¿ç·þ·þÎñÆ÷
    
    # ¡¾×¢¡¿Ö»Í¬²½¸ø¿ç·þ·þÎñÆ÷£¬¸÷¿ç·þÑé֤ͨ¹ýºó£¬ÓÎÏ··þ²Å»áͨ¹ýËùÊô¿ç·þÈ¡µÃ×îÖյķÖÇøÐÅÏ¢
    if serverType == ShareDefine.serverType_Cross:
        Sync_CenterToCross_FamilyCrossCfg(serverID)
    return

def Sync_CenterToCross_FamilyCrossCfg(serverID=0):
    familyMgr = DBDataMgr.GetFamilyMgr()
    crossZoneCfgDict = familyMgr.GetCrossZoneCfgDict()
    if not crossZoneCfgDict:
        GameWorld.Log("ûÓй«»á»¥Í¨ÅäÖûòûÓÐÑéÖ¤ÕýÈ·µÄ»¥Í¨·ÖÇøÅäÖò»Í¨Öª£¡")
        return
    dataMsg = {"crossZoneCfgDict":crossZoneCfgDict}
    serverIDList = [serverID] if serverID else crossZoneCfgDict.keys()
    CrossMsg.SendToServer(ShareDefine.CC2C_FamilyCrossCfg, dataMsg, serverIDList, ShareDefine.dirType_Cross)
    return

def CC2C_FamilyCrossCfg(dataMsg, fromServerID, serverType):
    # ¿ç·þÖÐÐÄͬ²½µÄ·ÖÇøÅäÖ㬽ö¿ç·þ·þÎñÆ÷´¦Àí¼´¿É£¬ÓÎÏ··þÒÔËùÊô¿ç·þ´¦ÀíºóµÄ×îÖÕÊý¾ÝΪ׼
    if serverType != ShareDefine.serverType_CrossCenter:
        return
    updCrossZoneCfgDict = dataMsg["crossZoneCfgDict"]
    
    if not updCrossZoneCfgDict:
        return
    
    if GameWorld.GetServerType() != ShareDefine.serverType_Cross:
        return
    
    familyMgr = DBDataMgr.GetFamilyMgr()
    if not familyMgr.UpdCrossZoneCfgDict(updCrossZoneCfgDict):
        return
    Sync_CrossToServer_FamilyInfo()
    return

def Sync_CrossToServer_FamilyInfo(toServerID=0, syncZoneID=0, syncFamilyIDList=[]):
    ## ¿ç·þ·þÎñÆ÷ͬ²½»¥Í¨¹«»áÐÅÏ¢¸øÓÎÏ··þ
    # @param toServerID: ÓÐÖ¸¶¨ÓÎÏ··þÁ¬ÉÏʱֻ·¢¸ø¸Ã·þ£¬Ã»ÓеĻ°Ò»°ãÊÇ·ÖÇøÅäÖñä¸üʱÓÉ¿ç·þÖ÷¶¯Í¬²½ËùÓÐÏà¹ØÓÎÏ··þ
    
    GameWorld.DebugLog("Sync_CrossToServer_FamilyInfo toServerID=%s,syncZoneID=%s,syncFamilyIDList=%s" % (toServerID, syncZoneID, syncFamilyIDList))
    familyMgr = DBDataMgr.GetFamilyMgr()
    crossZoneCfgDict = familyMgr.GetCrossZoneCfgDict() # ÅäÖõĻ¥Í¨
    if not crossZoneCfgDict:
        return
    crossServerID = GameWorld.GetGameWorld().GetServerID()
    if crossServerID not in crossZoneCfgDict:
        return
    zoneCfgDict = crossZoneCfgDict[crossServerID]
    GameWorld.DebugLog("    crossServerID=%s,zoneCfgDict=%s" % (crossServerID, zoneCfgDict))
    
    for zoneID in familyMgr.GetZoneIDListThisServer():
        if syncZoneID and syncZoneID != zoneID:
            continue
        if zoneID not in zoneCfgDict:
            continue
        cfgServerIDList = zoneCfgDict[zoneID] # ÅäÖÃÐèÒª»¥Í¨µÄ·þÎñÆ÷ÐÅÏ¢£¬ÐèҪͬ²½¸øÕâЩ·þÎñÆ÷
        
        if toServerID:
            if not GameWorld.CheckServerIDInList(toServerID, cfgServerIDList):
                # ·ÇÖ¸¶¨Ä¿±ê·þÎñÆ÷ËùÊô·ÖÇø²»Í¬²½
                #GameWorld.DebugLog("    ·ÇÖ¸¶¨Ä¿±ê·þÎñÆ÷ËùÊô·ÖÇø²»Í¬²½ toServerID=%s" % (toServerID))
                continue
            toServerIDList = [toServerID]
        else:
            toServerIDList = cfgServerIDList
            
        zoneMgr = familyMgr.GetZoneFamilyMgr(zoneID)
        zoneServerIDList = zoneMgr.GetZoneServerIDList()
        
#        viewBaseDict = {}
#        for index in range(zoneMgr.GetCount()):
#            family = zoneMgr.GetAt(index)
#            familyID = family.GetID()
#            if syncFamilyIDList and familyID not in syncFamilyIDList:
#                continue
#            viewBase = familyMgr.GetFamilyViewBase(familyID)
#            viewBaseDict[familyID] = viewBase.GetSyncData()
            
        # ֻ֪ͨ¸øÒѾ­»¥Í¨µÄÏà¹Ø·þÎñÆ÷¼´¿É
        # ¹ØÓڲ鿴Íæ¼Ò
        # 1. ²é¿´Íæ¼ÒÖ±½Óµ½Íæ¼ÒËùÔÚ·þÎñÆ÷²éѯ¼´¿É£¬²é¿´Íæ¼ÒÐèÒª¹«»áµÄһЩ»ù±¾ÐÅÏ¢£¬Èç ¹«»áÃû¡¢»ÕÕ¡¢ÆìÖÄ¡¢»¥Í¨¿ç·þID µÈ
        # 2. Íæ¼Ò/²é¿´Íæ¼ÒÐÅÏ¢Ö»Ðè¼Ç¼ËùÊô¹«»áID¼´¿É£¬¹«»áÏà¹Ø»ù´¡ÐÅϢͨ¹ý FamilyViewBase »ñÈ¡£¬ÓÉ»¥Í¨ËùÔÚ¿ç·þͬ²½¹ýÀ´
        
        # ¹ØÓڲ鿴¹«»á
        # 1. ´Ó²é¿´Íæ¼ÒÖв鿴¹«»á£¬·¢Ë͹«»áID¡¢ËùÊô»¥Í¨¿ç·þID£¬Ö±½ÓȥĿ±ê·þÎñÆ÷²éѯ¼´¿É
        # 2. ´Ó¿ç·þ»î¶¯Öв鿴¹«»á£¬»î¶¯Ïà¹Ø¹«»á¼Ç¼ËùÊô»¥Í¨¿ç·þID£¬Í¬ÑùÖ±½ÓȥĿ±ê·þÎñÆ÷²éѯ¼´¿É
        
        dataMsg = {"crossZoneCfgDict":crossZoneCfgDict, "zoneID":zoneID, "zoneServerIDList":zoneServerIDList}
        CrossMsg.SendToClientServer(ShareDefine.C2S_FamilyCrossInfo, dataMsg, toServerIDList)
        
    return

def C2S_FamilyCrossInfo(dataMsg, fromServerID):
    ## ÓÎÏ··þÊÕµ½»¥Í¨¿ç·þͬ²½µÄ¹«»á»¥Í¨ÐÅÏ¢£¬°´·ÖÇøͬ²½
    
    familyMgr = DBDataMgr.GetFamilyMgr()
    familyMgr.SetCurCrossServerID(fromServerID) # Ö±½ÓÉèÖã¬Äĸö·þͬ²½¹ýÀ´µÄ¾ÍÊÇËùÊô¿ç·þID
    familyMgr.SetCurZoneID(dataMsg["zoneID"])
    
#    ## ±¾·þ¸üпç·þ»¥Í¨¹«»áµÄ»ù±¾ÐÅÏ¢
#    if "viewBaseDict" in dataMsg:
#        viewBaseDict = dataMsg["viewBaseDict"]
#        for familyID, syncData in viewBaseDict.items():
#            viewBase = familyMgr.GetFamilyViewBase(familyID)
#            viewBase.UpdSyncData(syncData)
            
    # »¥Í¨ÅäÖÃ
    if "crossZoneCfgDict" in dataMsg:
        # ÓÎÏ··þ²»ÓÃÑéÖ¤ÁË£¬Ö±½ÓÉèÖ㬿ç·þÖÐÐÄ¡¢¸ú¿ç·þÊý¾Ý·þÒѾ­ÑéÖ¤¹ýÁË£¬Ö»ÒªÑéÖ¤»¥Í¨Ìõ¼þ´«ÊäÊý¾ÝÂß¼­¼´¿É
        familyMgr.SetCrossZoneCfgDict(dataMsg["crossZoneCfgDict"])
        CheckCrossFamilyTransData(fromServerID)
        
    # ʵ¼ÊÒÑ»¥Í¨·ÖÇø
    if "zoneServerIDList" in dataMsg:
        curZoneServerIDList = familyMgr.GetCurZoneServerIDList()
        updZoneServerIDList = dataMsg["zoneServerIDList"]
        familyMgr.SetCurZoneServerIDList(updZoneServerIDList)
        if curZoneServerIDList != updZoneServerIDList:
            Sync_FamilyCrossInfo()
            
    return

def IsFamilyCross():
    ## ±¾·þ¹«»áÊÇ·ñÒÑ¿ç·þ
    return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_FamilyCrossState) == 1

def IsFamilyCrossInTransData():
    ## ±¾·þ¹«»áÊ״οç·þ»¥Í¨Í¬²½Êý¾ÝÖÐ
    return DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_FamilyTransDataTime) > 0

def CheckCrossFamilyTransData(connServerID=0, ignoreCD=False):
    ## ¼ì²é¿ç·þ¹«»á´«ÊäÊý¾Ý£¬·þÎñÆ÷Æô¶¯Ê±¡¢ondayʱ¼ì²é£¬»òGMµÈÖ¸¶¨Ç¿ÖƵ÷ÓÃ
    
    if IsFamilyCross():
        GameWorld.DebugLog("±¾·þ¹«»áÒѾ­¿ç·þÁË!")
        return
    
    NeedServerDay = IpyGameDataPY.GetFuncCfg("FamilyCross", 1)
    serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
    if serverDay < NeedServerDay:
        GameWorld.DebugLog("±¾·þ¹«»á»¥Í¨ËùÐ迪·þÌì²»×ã! serverDay=%s < %s" % (serverDay, NeedServerDay))
        return
    
    # Èç¹ûºÏ·þÒ²ÒÔÖ÷·þΪ׼£¬ËùÓкϷþµÄ·þÎñÆ÷ÒªÇó±¾Éí±ØÐëÒ²ÒѾ­ÊÇ¿ç·þ¹«»áµÄ²ÅÄܺϷþ
    familyMgr = DBDataMgr.GetFamilyMgr()
    crossZoneCfgDict = familyMgr.GetCrossZoneCfgDict()
    
    crossServerID = 0
    serverID = GameWorld.GetGameWorld().GetServerID()
    for cID, zoneDict in crossZoneCfgDict.items():
        for zoneID, serverIDRangeList in zoneDict.items():
            if GameWorld.CheckServerIDInList(serverID, serverIDRangeList):
                crossServerID = cID
                GameWorld.Log("±¾·þ¹«»áËùÊô¿ç·þID! serverID=%s,crossServerID=%s,zoneID=%s,serverIDRangeList=%s" % (serverID, crossServerID, zoneID, serverIDRangeList))
                break
        if crossServerID:
            break
    if not crossServerID:
        GameWorld.Log("±¾·þ¹«»áδ·ÖÅ以ͨ·ÖÇø! serverID=%s" % (serverID))
        return
    
    if connServerID:
        if connServerID != crossServerID:
            GameWorld.Log("±¾·þ¹«»á»¥Í¨·ÇÄ¿±ê¿ç·þID²»´¦Àí! serverID=%s,crossServerID=%s != %s" % (serverID, crossServerID, connServerID))
            return
    else:
        ssServer = CrossMgr.GetSSServerMgr().GetSSServer(crossServerID)
        connState = ssServer.GetConnState()
        if connState != ShareDefine.ssConn_Normal:
            GameWorld.Log("±¾·þ¹«»á»¥Í¨Ä¿±ê¿ç·þID·ÇÁ¬½Ó״̬! serverID=%s,crossServerID=%s,connState=%s" % (serverID, crossServerID, connState))
            return
        
    transDataTime = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_FamilyTransDataTime)
    if transDataTime and not ignoreCD:
        curTime = int(time.time())
        if curTime - transDataTime < 30 * 60: # 30·ÖÖÓÄÚ²»Öظ´´«Êä
            GameWorld.Log("±¾·þ¹«»á»¥Í¨´«ÊäÊý¾ÝÖÐ! serverID=%s,crossServerID=%s,transDataTime=%s" % (serverID, crossServerID, GameWorld.ChangeTimeNumToStr(transDataTime)))
            return
        
    GameWorld.Log("±¾·þ¹«»á¿ªÆô»¥Í¨¿ªÊ¼´«Ê乫»áÏà¹ØÊý¾Ý! serverID=%s,crossServerID=%s" % (serverID, crossServerID))
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_FamilyTransDataTime, int(time.time()))
    
    cntDict = {}
    familyMgr = DBDataMgr.GetFamilyMgr()
    syncData = familyMgr.GetSaveData(cntDict)
    familyIDList = familyMgr.GetFamilyIDList()
    
    GameWorld.Log("dataslen=%s" % len(syncData))
    CrossMsg.SendToCrossServer(ShareDefine.S2C_FamilyData, {"syncData":syncData, "familyIDList":familyIDList, "cntDict":cntDict}, [crossServerID])
    return

def S2C_FamilyData(dataMsg, fromServerID):
    syncData = dataMsg["syncData"]
    familyIDList = dataMsg["familyIDList"]
    cntDict = dataMsg["cntDict"]
    GameWorld.Log("ÊÕµ½ÓÎÏ··þͬ²½µÄ»¥Í¨¹«»áÊý¾Ý! fromServerID=%s,cntDict=%s,familyIDList=%s" % (fromServerID, cntDict, familyIDList))
    
    unpackRet = __unpackFamilyData(syncData, familyIDList, cntDict)
    isOK = unpackRet[0]
    if not isOK:
        errorMsg = unpackRet[1]
        GameWorld.SendGameErrorEx("S2C_FamilyDataError", "»¥Í¨¹«»áÊý¾Ýͬ²½Ê§°Ü! fromServerID=%s,errorMsg=%s" % (fromServerID, errorMsg))
        CrossMsg.SendToClientServer(ShareDefine.C2S_FamilyDataRet, {"isOK":False}, [fromServerID])
        return
    zoneID, familyDataList, memberDataList, actionDataList = unpackRet[1:]
    
    # ²åÈëÐÂÊý¾Ý£¬ÖØÃûµÄ»áÔÚ¼ÓÈë·ÖÇøºó×Ô¶¯¸ÄÃû
    familyMgr = DBDataMgr.GetFamilyMgr()
    zoneMgr = familyMgr.GetZoneFamilyMgr(zoneID)
    actionMgr = familyMgr.GetFamilyActionMgr()
    
    syncFamilyIDList = []
    for dbData in familyDataList:
        familyID = dbData.ID
        familyMgr.DelFamily(familyID, False) # ÿ´Î¶¼Ç¿ÖÆÏÈɾ³ý£¬Ö§³ÖÖظ´Í¬²½
        zoneMgr.AddFamilyToZone(familyMgr.InitFamilyInstance(dbData))
        syncFamilyIDList.append(familyID)
        
    # ³ÉÔ±
    for dbData in memberDataList:
        familyID = dbData.FamilyID
        family = familyMgr.FindFamily(familyID)
        if not family:
            continue
        family.InitMemberInstance(dbData)
        
    # ÐÐΪ
    for dbData in actionDataList:
        familyID = dbData.FamilyID
        
        familyID = dbData.FamilyID
        actionType = dbData.ActionType
        
        family = familyMgr.FindFamily(familyID)
        if not family:
            continue
        action = actionMgr.GetFamilyAction(familyID, actionType)
        action.InitActionInstance(dbData)
        
    # ͬ²½¸øÏàͬ»¥Í¨·ÖÇøµÄ·þÎñÆ÷
    Sync_CrossToServer_FamilyInfo(syncZoneID=zoneID, syncFamilyIDList=syncFamilyIDList)
    
    # ×îºó»Ø¸´Í¬²½½á¹û
    CrossMsg.SendToClientServer(ShareDefine.C2S_FamilyDataRet, {"isOK":True}, [fromServerID])
    return

def __unpackFamilyData(syncData, familyIDList, cntDict):
    ## ½â°ü£¬ÑéÖ¤Êý¾Ý
    # @param cntDict: {"familyDataCnt":familyDataCnt, "membreDataCnt":membreDataCnt, "actionDataCnt":actionDataCnt}
    
    errorMsg = ""
    datas, pos, dataslen = syncData, 0, len(syncData)
    GameWorld.Log("__unpackFamilyData: dataslen=%s" % dataslen)
    
    zoneIDDict = {}
    familyMgr = DBDataMgr.GetFamilyMgr()
    
    # ¹«»á
    familyDataList = []
    cnt, pos = CommFunc.ReadDWORD(datas, pos)
    GameWorld.Log("Read DBFamily count :%s" % cnt)
    for _ in xrange(cnt):
        dbData = DBStruct.tagDBFamily()
        pos += dbData.readData(datas, pos, dataslen)
        familyDataList.append(dbData)
        familyID = dbData.ID
        if familyID not in familyIDList:
            errorMsg = "ͬ²½µÄÊý¾Ý¹«»áID²»Æ¥Åä! familyID=%s not in %s" % (familyID, familyIDList)
            return False, errorMsg
        
        familyServerID = dbData.ServerID
        zoneID = familyMgr.GetZoneIDInThisServer(familyServerID)
        if zoneID <= 0:
            errorMsg = "ͬ²½µÄ¹«»áÊý¾Ý²»ÊôÓÚ±¾¿ç·þ! familyID=%s,familyServerID=%s,zoneID=%s" % (familyID, familyServerID, zoneID)
            return False, errorMsg
        zoneIDDict[zoneID] = familyServerID
        
    if len(zoneIDDict) != 1:
        errorMsg = "ͬ²½µÄ¹«»áÊý¾Ý·ÖÇøÒì³£¿ÉÄÜ´æÔÚ¶à¸ö·ÖÇø! zoneIDDict=%s" % zoneIDDict
        return False, errorMsg
    zoneID = zoneIDDict.keys()[0]
    
    uppackFamilyCnt = len(familyDataList)
    familyDataCnt = cntDict.get("familyDataCnt", 0)
    if uppackFamilyCnt != familyDataCnt:
        errorMsg = "ͬ²½µÄ¹«»á¸öÊý²»Æ¥Åä! uppackFamilyCnt=%s != %s" % (uppackFamilyCnt, familyDataCnt)
        return False, errorMsg
    
    # ³ÉÔ±
    memberDataList = []
    cnt, pos = CommFunc.ReadDWORD(datas, pos)
    GameWorld.Log("Read DBFamilyMem count :%s" % cnt)
    for _ in xrange(cnt):
        dbData = DBStruct.tagDBFamilyMem()
        pos += dbData.readData(datas, pos, dataslen)
        memberDataList.append(dbData)
        
    uppackMemberCnt = len(memberDataList)
    membreDataCnt = cntDict.get("membreDataCnt", 0)
    if uppackMemberCnt != membreDataCnt:
        errorMsg = "ͬ²½µÄ³ÉÔ±¸öÊý²»Æ¥Åä! uppackMemberCnt=%s != %s" % (uppackMemberCnt, membreDataCnt)
        return False, errorMsg
    
    # ÐÐΪ
    actionDataList = []
    cnt, pos = CommFunc.ReadDWORD(datas, pos)
    GameWorld.Log("Read DBFamilyAction count :%s" % cnt)
    for _ in xrange(cnt):
        dbData = DBStruct.tagDBFamilyAction()
        pos += dbData.readData(datas, pos, dataslen)
        actionDataList.append(dbData)
        
    uppackActionCnt = len(actionDataList)
    actionDataCnt = cntDict.get("actionDataCnt", 0)
    if uppackMemberCnt != membreDataCnt:
        errorMsg = "ͬ²½µÄÐÐΪ¸öÊý²»Æ¥Åä! uppackActionCnt=%s != %s" % (uppackActionCnt, actionDataCnt)
        return False, errorMsg
    
    return True, zoneID, familyDataList, memberDataList, actionDataList

def C2S_FamilyDataRet(dataMsg, fromServerID):
    isOK = dataMsg["isOK"]
    GameWorld.Log("ÊÕµ½»¥Í¨¹«»áÊý¾Ýͬ²½½á¹û! fromServerID=%s,isOK=%s" % (fromServerID, isOK))
    # ÖØÖô«ÊäÊý¾Ý״̬
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_FamilyTransDataTime, 0)        
    if not isOK:
        # ʧ°Ü£¬ÔÝʱ»¹ÊÇʹÓñ¾·þ¹«»á£¬µÈOndayÔÙ´¥·¢£¬»òÅŲéÎÊÌâºóά»¤£¬ºóÐøÔÙÓÅ»¯¶à´Îͬ²½·½°¸
        # ÔËάÓʼþÒÑÔÚ¿ç·þ·¢ËÍ£¬²»·þ¿É²»´¦Àí
        return
    
    GameWorld.Log("»¥Í¨¹«»áÊý¾Ýͬ²½³É¹¦£¬±¾·þÕýʽ¿ªÆô¿ç·þ¹«»á»¥Í¨! fromServerID=%s" % (fromServerID))
    DBDataMgr.GetEventTrigMgr().SetValue(ShareDefine.Def_FamilyCrossState, 1)
    ChPlayer.SyncOnlinePlayerToCross(fromServerID)        
    return

def OnMinute():
    
    if GameWorld.IsMainServer():
        if IsFamilyCross():
            # ÓÎÏ··þ¹«»áÒÑ¿ç·þ²»´¦Àí
            return
        
    familyMgr = DBDataMgr.GetFamilyMgr()
    # ÿ·ÖÖÓË¢ÐÂÏÂÏÉÃËÕ½Á¦ÅÅÐò
    for zoneID in familyMgr.GetZoneIDListThisServer():
        zoneMgr = familyMgr.GetZoneFamilyMgr(zoneID)
        zoneMgr.Sort(True)
        
    return

def Sync_FamilyCrossInfo(curPlayer=None):
    ## ͬ²½±¾·þ¹«»á»¥Í¨ÐÅÏ¢
    if not IsFamilyCross():
        return
    familyMgr = DBDataMgr.GetFamilyMgr()
    clientPack = ChPyNetSendPack.tagSCFamilyCrossInfo()
    clientPack.ZoneID = familyMgr.GetCurZoneID()
    clientPack.ServerIDList = familyMgr.GetCurZoneServerIDList()
    clientPack.ServerCnt = len(clientPack.ServerIDList)
    if curPlayer:
        NetPackCommon.SendFakePack(curPlayer, clientPack)
    else:
        NetPackCommon.SendFackPackOnline(clientPack)
    return