#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GameWorldFamilyWar
#
# @todo:ÏÉÃËÁªÈü
# @author hxp
# @date 2018-01-12
# @version 1.0
#
# ÏêϸÃèÊö: ÏÉÃËÁªÈü
#
#-------------------------------------------------------------------------------
#"""Version = 2018-01-12 15:00"""
#-------------------------------------------------------------------------------
import GameWorld
import IpyGameDataPY
import IPY_GameServer
import PlayerCompensation
import PlayerUniversalGameRec
import PlayerFamilyRedPacket
import PlayerDBGSEvent
import ChPyNetSendPack
import NetPackCommon
import PlayerControl
import PlayerFamily
import AuctionHouse
import ShareDefine
import PyGameData
import ChConfig
import random
import copy
'''
1. ÏÉÃ˸ÄÃû
2. ±ÈÈüʱÏÉÃ˹ØÏµ±ä¸ü£¬¸±±¾½øÐÐÖв»¿É±ä¸üÏÉÃ˹ØÏµ
3. ÏÉÃ˽âÉ¢, »î¶¯Ê±¸üнâÉ¢ÁÐ±í£¬»î¶¯ºó¸üÐÂÆÀ¼¶
'''
FamilyWarRound_First = 1 # Ê×ÂÖ
FamilyWarRound_Second = 2 # ´ÎÂÖ
FamilyWar_MaxGroupID = 5 # ÁªÈü·Ö×éÊý
FamilyWar_GroupFamilyCount = 4 # ÿ×éÏÉÃËÊý
FamilyWar_MaxFamilyCount = FamilyWar_MaxGroupID * FamilyWar_GroupFamilyCount # ×î´ó±ÈÈüÏÉÃËÊý
## ʮλ: µÚ¼¸ÂÖ;  ¸öλ: 1-·Ö×é, 2-Õ½¶·, 3-½áÊø;  99-ÌØÊâÖµ ÏÂÖÜ·Ö×鶨¼¶
FamilyWarState_FirstRoundGroup = 11 # Ê×ÂÖ·Ö×é
FamilyWarState_FirstRoundBattle = 12 # Ê×ÂÖÕ½¶·
FamilyWarState_FirstRoundOver = 13 # Ê×ÂÖ½áÊø
FamilyWarState_SecondRoundGroup = 21 # ´ÎÂÖ·Ö×é
FamilyWarState_SecondRoundBattle = 22 # ´ÎÂÖÕ½¶·
FamilyWarState_SecondRoundOver = 23 # ´ÎÂÖ½áÊø
FamilyWarState_NextWeekGroupRank = 99 # ÏÂÖÜ·Ö×鶨¼¶
''' ¶ÔÕ½¼Ç¼ Def_UniversalGameRecType_FamilyWarBattle
value1        ×é¼¶±ð
value2        µÚ¼¸ÂÖ
value3        ¼Ò×åID1
value4        ¼Ò×åID2
value5        ʤÀû¼Ò×åID
strValue1        ¼Ò×åÃû1
strValue2        ¼Ò×åÃû2
strValue3        [½âÉ¢µÄ¼Ò×åID, ½âÉ¢µÄ¼Ò×åID]
'''
def GetBatRecGroupID(recData): return recData.GetValue1()
def SetBatRecGroupID(recData, groupID): return recData.SetValue1(groupID)
def GetBatRecRoundNum(recData): return recData.GetValue2()
def SetBatRecRoundNum(recData, roundNum): return recData.SetValue2(roundNum)
def GetBatRecFamilyIDA(recData): return recData.GetValue3()
def SetBatRecFamilyIDA(recData, familyIDA): return recData.SetValue3(familyIDA)
def GetBatRecFamilyIDB(recData): return recData.GetValue4()
def SetBatRecFamilyIDB(recData, familyIDB): return recData.SetValue4(familyIDB)
def GetBatRecWinFamilyID(recData):return recData.GetValue5()
def SetBatRecWinFamilyID(recData, winFamilyID): return recData.SetValue5(winFamilyID)
def GetBatRecFamilyNameA(recData): return recData.GetStrValue1()
def SetBatRecFamilyNameA(recData, familyNameA): return recData.SetStrValue1(familyNameA)
def GetBatRecFamilyNameB(recData): return recData.GetStrValue2()
def SetBatRecFamilyNameB(recData, familyNameB): return recData.SetStrValue2(familyNameB)
def GetBatRecDissolutionID(recData): return [] if not recData.GetStrValue3() else eval(recData.GetStrValue3()) # ½âÉ¢µÄ¼Ò×åIDÁбí [familyID, ...]
def SetBatRecDissolutionID(recData, dissFamilyIDList): return recData.SetStrValue3(str(dissFamilyIDList))
''' ÍõÕßÏÉÃË Def_UniversalGameRecType_FamilyWarChampion
value1        ¼Ò×åID
value2        ÃËÖ÷ID
value3        Á¬Ê¤´ÎÊý
value4        ÒÑ·ÖÅäµ½µÄÁ¬Ê¤´ÎÊý
value5        ÖÕ½áÁ¬Ê¤µÄ½±Àø´ÎÊý, Ö»ÄÜ»ñµÃÕâÒ»´ÎµÄÁ¬Ê¤½±Àø£¬ÓÐÖµ²ÅÏÔʾ£¬·ÖÅäºóÉèÖÃΪ0, ÓÅÏÈ·ÖÅä
strValue1        ÏÉÃËÃû
'''
def GetFWChampionFamilyID(championRecData): return championRecData.GetValue1()
def SetFWChampionFamilyID(championRecData, familyID): return championRecData.SetValue1(familyID)
def GetFWChampionLeaderID(championRecData): return championRecData.GetValue2()
def SetFWChampionLeaderID(championRecData, leaderID): return championRecData.SetValue2(leaderID)
def GetFWChampionWinCount(championRecData): return championRecData.GetValue3()
def SetFWChampionWinCount(championRecData, winCount): return championRecData.SetValue3(winCount)
def GetFWChampionWinRewardAllot(championRecData): return championRecData.GetValue4()
def SetFWChampionWinRewardAllot(championRecData, allotWinCount): return championRecData.SetValue4(allotWinCount)
def GetFWChampionEndWinCount(championRecData): return championRecData.GetValue5()
def SetFWChampionEndWinCount(championRecData, endWinCount): return championRecData.SetValue5(endWinCount)
def GetFWChampionFamilyName(championRecData): return championRecData.GetStrValue1()
def SetFWChampionFamilyName(championRecData, familyName): return championRecData.SetStrValue1(familyName)
''' ²ÎÈüÈËÔ± Def_UniversalGameRecType_FamilyWarMember
value1        Íæ¼ÒID
value2        ÏÉÃËID
value3        ÊÇ·ñÓвÎÓë
'''
def GetFWMemPlayerID(recData): return recData.GetValue1()
def SetFWMemPlayerID(recData, playerID): return recData.SetValue1(playerID)
def GetFWMemFamilyID(recData): return recData.GetValue2()
def SetFWMemFamilyID(recData, familyID): return recData.SetValue2(familyID)
def GetFWMemIsJoin(recData): return recData.GetValue3()
def SetFWMemIsJoin(recData, isJoin): return recData.SetValue3(isJoin)
#-------------------------------------------------------------------------------
def OnGameServerInitOK():
    ## ·þÎñÆ÷Æô¶¯³É¹¦
    
    # ¼ÓÔØ±¾ÖܲμÓÏÉÃËÁªÈüµÄÏÉÃ˼°ÏÉÃ˳ÉÔ± (ÏÉÃ˳ÉÔ±²»Ò»¶¨»¹ÔÚÔÏÉÃË)
    
    PyGameData.g_familyWarMemDict = {}
    PyGameData.g_familyWarFamilyIDList = []
    
    warMemRecList = GameWorld.GetUniversalRecMgr().GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarMember)
    for i in xrange(warMemRecList.Count()):
        recData = warMemRecList.At(i)
        warPlayerID = GetFWMemPlayerID(recData)
        warFamilyID = GetFWMemFamilyID(recData)
        if warFamilyID not in PyGameData.g_familyWarFamilyIDList:
            PyGameData.g_familyWarFamilyIDList.append(warFamilyID)
        PyGameData.g_familyWarMemDict[warPlayerID] = recData
        
    GameWorld.Log("¼ÓÔØÏÉÃËÁªÈü²ÎÈüÏÉÃËID: %s" % PyGameData.g_familyWarFamilyIDList)
    #GameWorld.Log("¼ÓÔØÏÉÃËÁªÈü²ÎÈüÏÉÃËÍæ¼Ò: %s" % PyGameData.g_familyWarMemDict)
    return
def DoFamilyWarReset(isDelRec=True):
    ## ÖØÖÃÏÉÃËÁªÈü
    
    PyGameData.g_familyWarFightingIDList = []
    PyGameData.g_familyWarFamilyIDList = []
    
    playerManager = GameWorld.GetPlayerManager()
    for playerID in PyGameData.g_familyWarMemDict.keys():
        player = playerManager.FindPlayerByID(playerID)
        if player:
            __NotifyPlayerJoinFamilyInfo(player, 0)
    PyGameData.g_familyWarMemDict = {}
    
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round, 0)
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_AllOver, 0)
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_StartWorldLV, 0)
    if isDelRec:
        GameWorld.GetUniversalRecMgr().Delete(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
        GameWorld.GetUniversalRecMgr().Delete(ShareDefine.Def_UniversalGameRecType_FamilyWarChampion)
        GameWorld.GetUniversalRecMgr().Delete(ShareDefine.Def_UniversalGameRecType_FamilyWarMember)
    GameWorld.Log("ÖØÖÃÏÉÃËÁªÈü£¡isDelRec=%s" % isDelRec)
    return
def CheckPlayerCanEnterFamilyWarFBMap(curPlayer):
    ## ¼ì²éÍæ¼Ò¿É·ñ½øÈëÏÉÃËÁªÈüÕ½³¡¸±±¾
    
    playerID = curPlayer.GetPlayerID()
    familyID = curPlayer.GetFamilyID()
    if playerID not in PyGameData.g_familyWarMemDict:
        PlayerControl.NotifyCode(curPlayer, "PlayerNotInFamilyWarMemList")
        return False
    warFamilyID = GetFWMemFamilyID(PyGameData.g_familyWarMemDict[playerID])
    if familyID != warFamilyID:
        PlayerControl.NotifyCode(curPlayer, "PlayerWarFamilyIDIsChange")
        return False
    if not IsFamilyInWarFighting(warFamilyID):
        PlayerControl.NotifyCode(curPlayer, "PlayerFamilyWarIsOver")
        return False
    
    return True
def IsFamilyInWarFighting(familyID):
    ## ÏÉÃËÊÇ·ñÕýÔÚÏÉÃËÁªÈüÕ½¶·ÖÐ
    return familyID in PyGameData.g_familyWarFightingIDList
def OnPlayerLogin(curFamily, curPlayer):
    CheckPlayerJoinFamilyWarInfo(curPlayer)
    gameWorld = GameWorld.GetGameWorld()
    state = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_FamilyWar)
    if state:
        Sync_FamilyWarInfo(curPlayer)
    return
def CheckPlayerJoinFamilyWarInfo(curPlayer):
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_familyWarMemDict:
        return
    joinFamilyID = GetFWMemFamilyID(PyGameData.g_familyWarMemDict[playerID])
    if not joinFamilyID or curPlayer.GetFamilyID() == joinFamilyID:
        return
    
    __NotifyPlayerJoinFamilyInfo(curPlayer, joinFamilyID)
    return
def __NotifyPlayerJoinFamilyInfo(curPlayer, joinFamilyID):
    joinFamilyName = ""
    if joinFamilyID:
        joinFamily = GameWorld.GetFamilyManager().FindFamily(joinFamilyID)
        joinFamilyName = "" if not joinFamily else joinFamily.GetName()
    
    joinFamilyWarInfo = ChPyNetSendPack.tagGCPlayerJoinFamilyWarInfo()
    joinFamilyWarInfo.JoinFamilyID = joinFamilyID
    joinFamilyWarInfo.JoinFamilyName = joinFamilyName
    joinFamilyWarInfo.JoinFamilyNameLen = len(joinFamilyWarInfo.JoinFamilyName)
    NetPackCommon.SendFakePack(curPlayer, joinFamilyWarInfo)
    return
def OnDeleteFamily(familyID, familyWarRank):
    ## ÏÉÃ˽âÉ¢´¦Àí
    
    isWarFamily = False
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    for i in xrange(warBatRecList.Count()):
        recData = warBatRecList.At(i)
        familyIDA = GetBatRecFamilyIDA(recData)
        familyIDB = GetBatRecFamilyIDB(recData)
        if familyID in [familyIDA, familyIDB]:
            dissFamilyIDList = GetBatRecDissolutionID(recData)
            if familyID not in dissFamilyIDList:
                dissFamilyIDList.append(familyID)
                SetBatRecDissolutionID(recData, dissFamilyIDList)
                GameWorld.Log("¸üÐÂÏÉÃËÁªÈü¶ÔÕ½¼Ç¼½âÉ¢ÏÉÃËIDÊý¾Ý: delFamilyID=%s,roundNum=%s,groupID=%s,familyIDA=%s,familyIDB=%s,dissFamilyIDList=%s" 
                              % (familyID, GetBatRecRoundNum(recData), GetBatRecGroupID(recData), familyIDA, familyIDB, dissFamilyIDList))
                isWarFamily =True
                
    # Èç¹ûÊÇÁªÈüÏÉÃ˽âÉ¢£¬Ö÷¶¯Í¬²½Ò»´Î¶ÔÕ½ÐÅÏ¢
    if isWarFamily:
        PlayerUniversalGameRec.SendUniversalGameRecInfo(None, ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
        
    if familyWarRank:
        GameWorld.Log("½âÉ¢ÏÉÃË£¬´¥·¢¸üÐÂÏÉÃËÁªÈüÅÅÃû: delFamilyID=%s,familyWarRank=%s" % (familyID, familyWarRank))
        UpdFamilyWarRank()
        
    # ²¹·¢Î´·ÖÅäµÄÁ¬Ê¤½±Àø
    #AllotWinRewardBySystem(GetFamilyWarChampionRecData(), True)
    return
def OnChangeFamilyLeader(familyID, leaderID):
    ## ÏÉÃËÃËÖ÷±ä¸ü
    if not leaderID:
        return
    championRecData = GetFamilyWarChampionRecData()
    championFamilyID = GetFWChampionFamilyID(championRecData)
    if championFamilyID != familyID:
        return
    SetFWChampionLeaderID(championRecData, leaderID)
    return
def OnRenameFamily(familyID, familyName):
    ## ÏÉÃ˸ÄÃû
    
    isWarFamily = False
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    for i in xrange(warBatRecList.Count()):
        recData = warBatRecList.At(i)
        familyIDA = GetBatRecFamilyIDA(recData)
        familyIDB = GetBatRecFamilyIDB(recData)
        if familyID not in [familyIDA, familyIDB]:
            continue
        isWarFamily = True
        if familyID == familyIDA:
            SetBatRecFamilyNameA(recData, familyName)
        if familyID == familyIDB:
            SetBatRecFamilyNameB(recData, familyName)
        GameWorld.Log("ÏÉÃËÁªÈüÏÉÃ˸ÄÃû: familyID=%s,roundNum=%s,groupID=%s,familyIDA=%s,familyIDB=%s" 
                      % (familyID, GetBatRecRoundNum(recData), GetBatRecGroupID(recData), familyIDA, familyIDB))
        
    # Èç¹ûÊÇÁªÈüÏÉÃ˽âÉ¢£¬Ö÷¶¯Í¬²½Ò»´Î¶ÔÕ½ÐÅÏ¢
    if isWarFamily:
        PlayerUniversalGameRec.SendUniversalGameRecInfo(None, ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    return
def OnFamilyWarStateChange(stateValue):
    GameWorld.Log("ÏÉÃËÁªÈü״̬±ä¸ü: stateValue=%s" % stateValue)
    
    # Ê×ÂÖ·Ö×é
    if stateValue == FamilyWarState_FirstRoundGroup:
        DoLogicFamilyWar_FirstRoundGroup()
        
    # Ê×ÂÖ¿ªÕ½
    elif stateValue == FamilyWarState_FirstRoundBattle:
        OnFamilyWar_Start(FamilyWarRound_First)
    
    # Ê×ÂÖ½áÊø
    elif stateValue == FamilyWarState_FirstRoundOver:
        OnFamilyWar_Over(FamilyWarRound_First)
    
    # ´ÎÂÖ·Ö×é
    elif stateValue == FamilyWarState_SecondRoundGroup:
        DoLogicFamilyWar_SecondRoundGroup()
        
    # ´ÎÂÖ¿ªÕ½
    elif stateValue == FamilyWarState_SecondRoundBattle:
        OnFamilyWar_Start(FamilyWarRound_Second)
    
    # ´ÎÂÖ½áÊø
    elif stateValue == FamilyWarState_SecondRoundOver:
        OnFamilyWar_Over(FamilyWarRound_Second)
    
    # ÏÂÖÜ·Ö×鶨¼¶
    elif stateValue == FamilyWarState_NextWeekGroupRank:
        pass
        #·ÏÆú¸Ã½×¶ÎÂß¼£¬ÒòΪ²»ÔÙÖ§³Öµ¥´Î»î¶¯ÖÜÆÚ¿çÌ죬ËùÒÔ¸ÄΪ¹ýÌìʱ´¥·¢¼ì²éһϼ´¿É
        #DoLogicFamilyWar_NextWeekGroupRank()
        
    else:
        GameWorld.ErrLog("²»´æÔÚ¸ÃÏÉÃËÁªÈü״̬£¡stateValue=%s" % stateValue)
        
    return
def OnMapServerInitOK():
    # ÉÏÖܹھüID
    championFamilyID = GetFWChampionFamilyID(GetFamilyWarChampionRecData())
    GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_ChampionFamilyID, championFamilyID)
    
    # µ±Ç°¶ÔÕ½ÏÉÃËÃ÷ϸ
    canEnter = GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_FBCanEnter % ChConfig.Def_FBMapID_FamilyWar)
    roundNum = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
    if canEnter and roundNum:
        GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_VSFamilyInfo, GetRoundOpenFBVSFamilyInfo(roundNum))
        
    return
def GetRoundOpenFBVSFamilyInfo(roundNum):
    ## »ñÈ¡ÂִοɿªÆô¸±±¾µÄ±ÈÈüÐÅÏ¢
    
    championRecData = GetFamilyWarChampionRecData()
    championFamilyID = GetFWChampionFamilyID(championRecData)
    championWinCount = GetFWChampionWinCount(championRecData)
    GameWorld.Log("    ÏÉÃËÁªÈüÀúÊ·¹Ú¾ü: championFamilyID=%s,championWinCount=%s" % (championFamilyID, championWinCount))
    
    vsFamilyInfo = []
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    finalMatchState = False # ÊÇ·ñÒѾ´¦Àí¹ý×ܾöÈü³¡´Î
    warBatRecCount = warBatRecList.Count()
    
    for i in xrange(warBatRecCount):
        recData = warBatRecList.At(i)
        if roundNum != GetBatRecRoundNum(recData):
            continue
        # Ö»ÓÐÒì³£±ÈÈü »òÕß ´ÎÂֵĵÚÒ»Ìõ¼Ç¼Ϊ¾öÈü³¡
        isFinalMatch = (warBatRecCount == 1) or (not finalMatchState and roundNum == FamilyWarRound_Second)
        if isFinalMatch:
            finalMatchState = True
        familyIDA = GetBatRecFamilyIDA(recData)
        familyIDB = GetBatRecFamilyIDB(recData)
        familyNameA = GetBatRecFamilyNameA(recData)
        familyNameB = GetBatRecFamilyNameB(recData)
        if not familyIDA or not familyIDB:
            GameWorld.Log("    ÓÐÏÉÃËÂÖ¿Õ£¬²»¿ªÆô±¾³¡±ÈÈü£¡i=%s,familyIDA=%s,familyIDB=%s" % (i, familyIDA, familyIDB))
            continue
        disFamilyIDList = GetBatRecDissolutionID(recData)
        if disFamilyIDList:
            GameWorld.Log("    ÓÐÏÉÃ˽âÉ¢£¬²»¿ªÆô±¾³¡±ÈÈü£¡i=%s,familyIDA=%s,familyIDB=%s" % (i, familyIDA, familyIDB))
            continue
        winFamilyID = GetBatRecWinFamilyID(recData)
        if winFamilyID:
            GameWorld.Log("    ÒÑÓÐʤ¸º½á¹ûµÄ£¬²»¿ªÆô±¾³¡±ÈÈü£¡i=%s,familyIDA=%s,familyIDB=%s,winFamilyID=%s" 
                          % (i, familyIDA, familyIDB, winFamilyID))
            continue
        
        groupID = GetBatRecGroupID(recData)
        familyRankA = PlayerFamily.GetFamilyIDRank(familyIDA)
        familyRankB = PlayerFamily.GetFamilyIDRank(familyIDB)
        winCountA = championWinCount if familyIDA == championFamilyID else 0
        winCountB = championWinCount if familyIDB == championFamilyID else 0
        
        vsFamilyInfo.append([isFinalMatch, roundNum, groupID, [familyIDA, familyIDB], [familyRankA, familyRankB], [familyNameA, familyNameB], [winCountA, winCountB]])
        
    return vsFamilyInfo
def OnFamilyWar_Start(roundNum):
    ## ÏÉÃËÁªÈü¶ÔÕ½¿ªÊ¼
    curRound = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
    if curRound != roundNum:
        GameWorld.ErrLog("µ±Ç°ÂÖ´ÎÒì³£Êý¾Ý£¬ÎÞ·¨¿ªÆôÏÉÃËÁªÈü!dbRound=%s,startRound=%s" % (curRound, roundNum))
        return
    GameWorld.Log("==========ÏÉÃËÁªÈüÕ½¶·¿ªÊ¼, µ±Ç°ÂÖ´Î(%s)=========" % (roundNum))
    vsFamilyInfo = GetRoundOpenFBVSFamilyInfo(roundNum)
    GameWorld.Log("    vsFamilyInfo=%s" % (vsFamilyInfo))
    
    # ¸üÐÂÕ½¶·ÖеÄÏÉÃËIDÁбí
    PyGameData.g_familyWarFightingIDList = []
    for vsFamily in vsFamilyInfo:
        PyGameData.g_familyWarFightingIDList.extend(vsFamily[ShareDefine.VSFamilyInfo_FamilyIDList])
        
    GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_VSFamilyInfo, vsFamilyInfo)
    if vsFamilyInfo:
        # ֪ͨµØÍ¼¿ªÆô¸±±¾¶ÔÕ½·ÖÏß
        msgInfo = str(vsFamilyInfo)
        GameWorld.GetPlayerManager().MapServer_QueryPlayer(0, 0, 0, ChConfig.Def_FBMapID_FamilyWar, 
                                                           "FamilyWarStart", msgInfo, len(msgInfo))
    return
def DoLogicFamilyWar_FirstRoundGroup():
    ## Ê×ÂÖ¶ÔÕ½·Ö×é
    curRound = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
    if curRound == FamilyWarRound_First:
        GameWorld.DebugLog("ÏÉÃËÁªÈüÒѾ´¦Àí¹ýÊ×ÂÖ·Ö×飡")
        return
    if curRound != 0:
        GameWorld.ErrLog("ÏÉÃËÁªÈü´¦Àí¹ýÊ×ÂÖ·Ö×éÂִμǼֵÒì³££¡curRound=%s" % curRound)
        return
    
    GameWorld.Log("============= ¿ªÊ¼ÏÉÃËÁªÈü·Ö×éÊ×ÂÖ =============")
    
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_AllOver, 0) # ÐÂÒ»ÂÖ¿ªÊ¼£¬ÖØÖÃ״̬
    PlayerFamily.DoFamilySort() # Ê×ÂÖ·Ö×éǰÐèÒªÇ¿ÖÆË¢ÐÂÒ»´ÎÏÉÃËÅÅÐÐ
    
    lastFamilyWarMemDict = {}
    for warPlayerID, recData in PyGameData.g_familyWarMemDict.items():
        lastFamilyWarMemDict[warPlayerID] = GetFWMemFamilyID(recData)
    PyGameData.g_familyWarMemDict = {}
    PyGameData.g_familyWarFamilyIDList = []
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    universalRecMgr.Delete(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle) # ´¦ÀíÊ×ÂÖÐèÏÈÇå¿Õ¶ÔÕ½±í
    universalRecMgr.Delete(ShareDefine.Def_UniversalGameRecType_FamilyWarMember) # Çå¿Õ²ÎÈüÈËÔ±¼Ç¼
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    warMemRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarMember)
    
    groupID = FamilyWar_MaxGroupID
    groupFamilyList = []
    warFamilyMemInfo = {}
    #Ö±½ÓÈ¡ÅÅÐаñǰXÃû×÷ΪÁªÈüÏÉÃËÃûµ¥
    familyMgr = GameWorld.GetFamilyManager()
    sortFamilyIDList = PlayerFamily.GetSortFamilyIDList()
    familyCount = len(sortFamilyIDList)
    joinFamilyLVLimit = IpyGameDataPY.GetFuncCfg("FamilyMatchSet", 1)
    GameWorld.DebugLog("×îµÍ²ÎÈüÏÉÃ˵ȼ¶£º %s" % joinFamilyLVLimit)
    for i, familyID in enumerate(sortFamilyIDList):
        family = familyMgr.FindFamily(familyID)
        if not family:
            GameWorld.ErrLog("ÏÉÃËÁªÈüÊ×ÂÖ·Ö×éʱÎÞ·¨ÕÒµ½¸ÃÏÉÃË: i=%s,familyID=%s" % (i, familyID))
            continue
        if family.GetLV() < joinFamilyLVLimit:
            GameWorld.Log("ÏÉÃ˵ȼ¶²»×㣬ÎÞ·¨²ÎÓëÁªÈü£¡familyID=%s,LV=%s,joinFamilyLVLimit=%s" % (familyID, family.GetLV(), joinFamilyLVLimit))
        else:
            groupFamilyList.append(family)
            
            # Ìí¼Ó²ÎÈüÏÉÃ˼°³ÉÔ±Ãûµ¥
            PyGameData.g_familyWarFamilyIDList.append(familyID)
            warMemIDList = []
            for index in xrange(family.GetCount()):
                curMember = family.GetAt(index)
                memPlayerID = curMember.GetPlayerID()
                memPlayer = curMember.GetPlayer()
                isAddOK = AddFamilyWarMem(memPlayerID, familyID, warMemRecList)
                lastJoinFamilyID = lastFamilyWarMemDict.get(memPlayerID, 0)
                # ÖØÐÂÍ¨ÖªÍæ¼Ò²ÎÓëµÄÏÉÃË
                if lastJoinFamilyID and isAddOK and lastJoinFamilyID != familyID and memPlayer:
                    __NotifyPlayerJoinFamilyInfo(memPlayer, familyID)
                if isAddOK:
                    warMemIDList.append(memPlayerID)
            warFamilyMemInfo[familyID] = warMemIDList
                
        # ÂúÒ»×éÏÉÃËÊý or ûÓÐÏÉÃËÁË
        if len(groupFamilyList) == FamilyWar_GroupFamilyCount or i == familyCount - 1:
            __DoFristRoundRandBattle(warBatRecList, groupID, groupFamilyList)
            # 1Ϊ×îµÍ¼¶ÁªÈü×é
            if groupID == 1:
                break
            else:
                # ÏÂÒ»×é
                groupID -= 1
                groupFamilyList = []
    
    worldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)            
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_StartWorldLV, worldLV) # ÉèÖ÷Ö×éʱµÄÊÀ½çµÈ¼¶
    
    GameWorld.Log("    PyGameData.g_familyWarFamilyIDList: %s" % PyGameData.g_familyWarFamilyIDList)
    GameWorld.Log("    warFamilyMemInfo: %s" % warFamilyMemInfo)
    GameWorld.Log("    ͨÓüǼ¶ÔÕ½¼Ò×åÊý: %s" % warBatRecList.Count())
    GameWorld.Log("    ͨÓüǼ²ÎÓëÍæ¼ÒÊý: %s" % warMemRecList.Count())
    GameWorld.Log("    µ±Ç°ÊÀ½çµÈ¼¶: %s" % worldLV)
    GameWorld.Log("    ÏÉÃËÁªÈüÊ×ÂÖ±ÈÈü·Ö×éÈ·ÈÏÍê±Ï£¡")
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round, FamilyWarRound_First) # ÉèÖÃÒÑ´¦Àí¹ýµÄÂÖ´Î
    Sync_FamilyWarInfo()
    return
def AddFamilyWarMem(playerID, familyID, warMemRecList=None):
    ## Ìí¼ÓÏÉÃËÁªÈü²ÎÈüÈËÔ±
    if familyID not in PyGameData.g_familyWarFamilyIDList:
        GameWorld.DebugLog("·Ç²ÎÈüÏÉÃË£¬²»ÄÜÌí¼Ó²ÎÈü³ÉÔ±£¡familyID=%s" % familyID)
        return
    if playerID in PyGameData.g_familyWarMemDict:
        GameWorld.DebugLog("±¾ÖÜÒѾÌí¼Ó¹ý¸Ã³ÉÔ±ËùÊô²ÎÈüÏÉÃË£¬²»Öظ´Ìí¼Ó£¡playerID=%s,familyID=%s,warFamilyID=%s" 
                           % (playerID, familyID, GetFWMemFamilyID(PyGameData.g_familyWarMemDict[playerID])))
        return
    if not warMemRecList:
        warMemRecList = GameWorld.GetUniversalRecMgr().GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarMember)
    if not warMemRecList:
        return
    recData = warMemRecList.AddRec()
    SetFWMemPlayerID(recData, playerID)
    SetFWMemFamilyID(recData, familyID)
    PyGameData.g_familyWarMemDict[playerID] = recData # ÉèÖÃÍæ¼Ò¶ÔÓ¦µÄÏÉÃËID£¬±¾ÖÜÁªÈüÖ»ÄÜÔÚ¸ÃÏÉÃËʱ²ÅÄܽøÈëÕ½³¡
    GameWorld.DebugLog("    Ìí¼ÓÏÉÃËÁªÈüÕ½¶·ÈËÔ±: playerID=%s,familyID=%s" % (playerID, familyID))
    return True
def OnPlayerChangeMap(curPlayer):
    ## Íæ¼Ò½øÈëÏÉÃËÁªÈüµØÍ¼
    if curPlayer.GetMapID() != ChConfig.Def_FBMapID_FamilyWar:
        return
    playerID = curPlayer.GetPlayerID()
    familyID = curPlayer.GetFamilyID()
    if playerID not in PyGameData.g_familyWarMemDict:
        return
    recData = PyGameData.g_familyWarMemDict[playerID]
    if GetFWMemIsJoin(recData):
        GameWorld.DebugLog("ÒѾ½øÈë¹ýÏÉÃËÁªÈüÕ½³¡! ", playerID)
        return
    warFamilyID = GetFWMemFamilyID(recData)
    if familyID != warFamilyID:
        GameWorld.DebugLog("½øÈëÕ½³¡Ê±²ÎÈüÏÉÃËID²»Ò»ÖÂ! familyID=%s,warFamilyID=%s" % (familyID, warFamilyID), playerID)
        return
    SetFWMemIsJoin(recData, 1)
    GameWorld.Log("Íæ¼Ò½øÈëÏÉÃËÁªÈüÕ½³¡: familyID=%s" % (familyID), playerID)
    return
def __DoFristRoundRandBattle(warBatRecList, groupID, groupFamilyList):
    ## Ö´ÐÐÊ×ÂÖÁªÈü·Ö×éÏÉÃËËæ»úÆ¥Åä±ÈÈü, Á½Á½Ëæ»ú
    if not groupFamilyList:
        return
    random.shuffle(groupFamilyList) # ´òÂÒ˳Ðò, Á½Á½¶ÔÕ½
    roundNum = FamilyWarRound_First
    while groupFamilyList:
        vaFamilyList = groupFamilyList[:2]
        groupFamilyList = groupFamilyList[2:]
        
        familyA = vaFamilyList[0]
        familyB = vaFamilyList[1] if len(vaFamilyList) > 1 else None
        familyIDA, familyNameA = familyA.GetID(), familyA.GetName() # AÏÉÃËÒ»¶¨´æÔÚ, BÏÉÃË¿ÉÄÜΪ¿Õ
        familyIDB = 0 if not familyB else familyB.GetID()
        familyNameB = "" if not familyB else familyB.GetName()
        # Ê×Âֵϰֱ½Ó´ÓÏÉÃËÅÅÐаñÉÏÈ¡£¬ËùÒÔÒ»¶¨ÊÇ´æÔÚµÄÏÉÃË£¬¹ÊûÓнâÉ¢ÏÉÃËÐÅÏ¢
        AddFamilyWarBatRec(warBatRecList, roundNum, groupID, familyIDA, familyIDB, familyNameA, familyNameB)
        
    return
def AddFamilyWarBatRec(warBatRecList, roundNum, groupID, familyIDA, familyIDB, familyNameA, familyNameB, disFamilyIDList=[]):
    ## Ìí¼Ó±ÈÈüÆ¥Åä¶ÔÕ½¼Ç¼
    if not familyIDA and not familyIDB:
        return
    recData = warBatRecList.AddRec()
    SetBatRecGroupID(recData, groupID)
    SetBatRecRoundNum(recData, roundNum)
    SetBatRecFamilyIDA(recData, familyIDA)
    SetBatRecFamilyIDB(recData, familyIDB)
    SetBatRecFamilyNameA(recData, familyNameA)
    SetBatRecFamilyNameB(recData, familyNameB)
    
    setDissFamilyIDList = []
    if familyIDA and familyIDA in disFamilyIDList:
        setDissFamilyIDList.append(familyIDA)
    if familyIDB and familyIDB in disFamilyIDList:
        setDissFamilyIDList.append(familyIDB)
    SetBatRecDissolutionID(recData, setDissFamilyIDList)
    
    GameWorld.Log("    AddRec roundNum=%s,groupID=%s,familyIDA(%s) VS familyIDB(%s), setDissFamilyIDList=%s" 
                  % (roundNum, groupID, familyIDA, familyIDB, setDissFamilyIDList))
    return
def DoLogicFamilyWar_SecondRoundGroup():
    ## ´ÎÂÖ¶ÔÕ½·Ö×é
    
    curRound = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
    if curRound == FamilyWarRound_Second:
        GameWorld.DebugLog("ÏÉÃËÁªÈüÒѾ´¦Àí¹ý´ÎÂÖ·Ö×飡")
        return
    if curRound != FamilyWarRound_First:
        GameWorld.ErrLog("ÏÉÃËÁªÈü´¦Àí¹ý´ÎÂÖ·Ö×éÂִμǼֵÒì³££¡curRound=%s" % curRound)
        return
    
    GameWorld.Log("============= ¿ªÊ¼ÏÉÃËÁªÈü·Ö×é´ÎÂÖ =============")
    secondRoundBatDict = {} # ¹é×éͳ¼Æ {ÁªÈü¼¶±ðID:[[familyIDA, familyIDB, winFamilyID, disFamilyIDList], ...], ...}
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    for i in xrange(warBatRecList.Count()):
        recData = warBatRecList.At(i)
        if FamilyWarRound_First != GetBatRecRoundNum(recData):
            continue
        groupID = GetBatRecGroupID(recData)
        fristRoundBatRec = secondRoundBatDict.get(groupID, [])
        fristRoundBatRec.append(recData)
        secondRoundBatDict[groupID] = fristRoundBatRec
        
    roundNum = FamilyWarRound_Second
    groupID = FamilyWar_MaxGroupID
    for i in xrange(FamilyWar_MaxGroupID):
        groupID = FamilyWar_MaxGroupID - i
        GameWorld.Log("-----groupID=%s-----" % groupID)
        ## ´ÎÂÖ·ÖÅ乿Ôò
        # Èç¹ûÏÉÃËÊý=1£¬²»´ò£¬¸ÃÏÉÃËĬÈÏ»ñµÃ±¾×éµÚÒ»Ãû
        # Èç¹ûÏÉÃËÊý=2£¬ÄÇôֻҪ´òÒ»ÂÖ£¬Ê×ÂÖÖ±½Ó¾ö³öµÚÒ»¡¢¶þÃû£¬´ÎÂÖ²»´ò
        # Èç¹ûÏÉÃËÊý>2£¬ÄÇôһ¶¨»á´òÁ½ÂÖ£¬×ñÑʤÕß¶ÔʤÕߣ¬°ÜÕß¶Ô°ÜÕߣ¬²»¿¼ÂÇÏÉÃ˽âÉ¢
        
        if groupID not in secondRoundBatDict:
            GameWorld.Log("    ûÓиü¶±ð±ÈÈü£¬½áÊø·Ö×é!roundNum=%s,groupID=%s" % (roundNum, groupID))
            continue
        fristRoundBatRec = secondRoundBatDict[groupID]
        if len(fristRoundBatRec) < 2:
            GameWorld.Log("    Ê×ÂÖ±ÈÈü²»ÊÇÁ½³¡£¬Ö±½ÓÌø¹ý´ÎÂÖ±ÈÈü!roundNum=%s,groupID=%s" % (roundNum, groupID))
            continue
        
        ## =========== ÒÔÏÂÂ߼ΪÊ×ÂÖ²ÎÈüµÄÏÉÃËÖÁÉÙÓÐ3¸öµÄÇé¿ö ==============
        
        recData1, recData2 = fristRoundBatRec
        winFamilyID1, winFamilyName1, loseFamilyID1, loseFamilyName1, disFamilyIDList1 = __GetWinLoseFamilyInfoForNextRound(recData1)
        winFamilyID2, winFamilyName2, loseFamilyID2, loseFamilyName2, disFamilyIDList2 = __GetWinLoseFamilyInfoForNextRound(recData2)
        disFamilyIDList = disFamilyIDList1 + disFamilyIDList2 # ´ÎÂÖÐèÒª´¦Àí½âÉ¢ÏÉÃËÐÅÏ¢
        # ʤÕß¶ÔʤÕߣ¬ °ÜÕß¶Ô°ÜÕߣ¬ÆäÖÐÒ»¸ö°ÜÕßÏÉÃË¿ÉÄÜΪ¿Õ
        GameWorld.Log("    ʤÕß¶ÔʤÕߣ¬°ÜÕß¶Ô°ÜÕß: winFamilyID1=%s,winFamilyID2=%s,loseFamilyID1=%s,loseFamilyID2=%s" 
                      % (winFamilyID1, winFamilyID2, loseFamilyID1, loseFamilyID2))
        AddFamilyWarBatRec(warBatRecList, roundNum, groupID, winFamilyID1, winFamilyID2, winFamilyName1, winFamilyName2, disFamilyIDList)
        AddFamilyWarBatRec(warBatRecList, roundNum, groupID, loseFamilyID1, loseFamilyID2, loseFamilyName1, loseFamilyName2, disFamilyIDList)
        
    GameWorld.Log("    ÏÉÃËÁªÈü´ÎÂÖ±ÈÈü·Ö×éÈ·ÈÏÍê±Ï£¡")
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round, FamilyWarRound_Second) # ÉèÖÃÒÑ´¦Àí¹ýµÄÂÖ´Î
    return
def __GetWinLoseFamilyInfoForNextRound(recData):
    '''¸ù¾ÝÉÏÒ»ÂÖ±ÈÈü½á¹û»ñÈ¡ÓÐ×ʸñ²ÎÓëÏÂÒ»ÂÖ±ÈÈüµÄʤÕßÓë°ÜÕßÏÉÃËÐÅÏ¢
    @param recData: ÉÏÒ»ÂÖ±ÈÈü½á¹û¼Ç¼Êý¾Ý
    ×¢: ÉÏÒ»ÂÖµÄʤÕßÓë°ÜÕß²¢²»Ò»¶¨¶¼ÓÐ×ʸñ²ÎÓëÏÂÒ»ÂÖ±ÈÈü£¬±ØÐëÂú×ãÆäÖÐÒ»¸öÏÉÃËδ½âÉ¢£¨¿ÉÄÜÈüǰ¡¢Èüºó½âÉ¢£©²ÅÄܲÎÓë;
    '''
    familyIDA = GetBatRecFamilyIDA(recData)
    familyIDB = GetBatRecFamilyIDB(recData)
    familyNameA = GetBatRecFamilyNameA(recData)
    familyNameB = GetBatRecFamilyNameB(recData)
    winFamilyID = GetBatRecWinFamilyID(recData)
    if not winFamilyID:
        winFamilyID = __SetBatRecWinFamilyIDBySystem(recData, familyIDA, familyIDB, False)
        
    # winFamilyIDÒ»¶¨»áÓÐID
    #if not winFamilyID:
    #    return
    
    if winFamilyID == familyIDB:
        winFamilyName = familyNameB
        loseFamilyID = familyIDA
        loseFamilyName = familyNameA
    else:
        winFamilyID = familyIDA
        winFamilyName = familyNameA
        loseFamilyID = familyIDB
        loseFamilyName = familyNameB
        
    disFamilyIDList = GetBatRecDissolutionID(recData)
    return winFamilyID, winFamilyName, loseFamilyID, loseFamilyName, disFamilyIDList
def __SetBatRecWinFamilyIDBySystem(recData, familyIDA, familyIDB, isFight=True):
    ''' ϵͳ¼ì²éÉèÖñÈÈüʤÕßÏÉÃË
    @param isFight: ÊÇ·ñÊDZÈÈüÖеģ¬Èç¹ûÊÇ£¬Ôò²»ÉèÖÃʤÕߣ¨ÂÖ¿Õ¼°½âÉ¢µÄ³ýÍ⣩
                        µ±²»ÊÇʱ£¬ÏµÍ³Ò»¶¨»áÇ¿ÖÆÉèÖÃÒ»¸öʤÕßÏÉÃËID£¬¼´Ê¹¸ÃÏÉÃËÒѾ½âÉ¢£¡
    Ê×ÂÖÓÐδÕý³£½áÊøµÄ£¬´ÎÂÖ¿ªÊ¼·ÖÅäʱ½øÐв¹´¦Àí
    ´ÎÂÖÓÐδÕý³£½áÊøµÄ£¬ÏÂÖÜ·Ö×鶨¼¶Ê±½øÐв¹´¦Àí
    ²¹´¦ÀíµÄÇé¿ö£¬Ò»¶¨»áÉèÖÃÒ»¸ö»ñʤID
    '''
    winFamilyID = GetBatRecWinFamilyID(recData)
    if winFamilyID:
        return winFamilyID
    
    winFamilyID = 0
    disFamilyIDList = GetBatRecDissolutionID(recData)
    # ÓÐÏÉÃ˽âÉ¢µÄÇé¿ö, ½âÉ¢¿ÉÄÜ·¢ÉúÔÚ ·Ö×éºó±ÈÈüǰ¡¢±ÈÈüºó¡¢´ÎÂÖ·Ö×éǰ£¬±ÈÈüʱ²»¿É±ä¸üÏÉÃ˹ØÏµ
    if disFamilyIDList:
        if familyIDA in disFamilyIDList and familyIDB in disFamilyIDList:
            winFamilyID = familyIDA
            GameWorld.Log("        Á½¸öÏÉÃ˶¼ÒѾ½âÉ¢£¬Ä¬ÈÏAʤ£¡familyIDA=%s,familyIDB=%s,disFamilyIDList=%s,winFamilyID=%s" 
                          % (familyIDA, familyIDB, disFamilyIDList, winFamilyID))
        elif familyIDA and familyIDB:
            winFamilyID = familyIDB if familyIDA in disFamilyIDList else familyIDA
            GameWorld.Log("        ¶ÔÕ½ÏÉÃËÒѾ½âÉ¢, Ö±½Ó»ñʤ: familyIDA=%s,familyIDB=%s,disFamilyIDList=%s,winFamilyID=%s" 
                          % (familyIDA, familyIDB, disFamilyIDList, winFamilyID))
        else:
            winFamilyID = familyIDA if not familyIDB else familyIDB
            GameWorld.Log("        ±ÈÈüÂÖ¿Õ, µ«ÏÉÃËÒѽâÉ¢, ĬÈÏ»ñʤ!familyIDA=%s,familyIDB=%s,disFamilyIDList=%s,winFamilyID=%s" 
                          % (familyIDA, familyIDB, disFamilyIDList, winFamilyID))
            
    # ·Ç±ÈÈüÖеÄʱºòÐèÒª¼ì²é·þÎñÆ÷Ò쳣ûÓнáËãµÄÇé¿ö
    elif not isFight and familyIDA and familyIDB:
        ## ×¢£º ´ËÇé¿öÖ»ÓÐÊǵØÍ¼·þÎñÆ÷³öÒì³££¬»òÕ߻ʱ¼ä·þÎñÆ÷´¦Óڹطþ»òÒì³£Çé¿öϲÅÓпÉÄÜ·¢Éú
        familyRankA = PlayerFamily.GetFamilyIDRank(familyIDA)
        familyRankB = PlayerFamily.GetFamilyIDRank(familyIDB)
        winFamilyID = familyIDA if familyRankA <= familyRankB else familyIDB
        GameWorld.Log("        ±ÈÈüÒ쳣ûÓÐÕý³£½áÊø, ÓÉϵͳĬÈÏÉèÖÃʤÕß!familyIDA=%s,familyRankA=%s,familyIDB=%s,familyRankB=%s,winFamilyID=%s" 
                      % (familyIDA, familyRankA, familyIDB, familyRankB, winFamilyID))
        
    # ÂÖ¿Õ
    elif not familyIDA or not familyIDB:
        winFamilyID = familyIDA if not familyIDB else familyIDB
        GameWorld.Log("        ±ÈÈüÂÖ¿Õ, ÓÉϵͳĬÈÏÉèÖÃʤÕß!familyIDA=%s,familyIDB=%s,winFamilyID=%s" 
                      % (familyIDA, familyIDB, winFamilyID))
    elif isFight:
        GameWorld.DebugLog("        ±ÈÈüÖУ¬²»ÉèÖÃʤÕß!familyIDA=%s,familyIDB=%s,disFamilyIDList=%s" % (familyIDA, familyIDB, disFamilyIDList))
        return 0
    
    if not winFamilyID:
        winFamilyID = familyIDA if not familyIDB else familyIDB
    if not winFamilyID:
        return 0
    
    SetBatRecWinFamilyID(recData, winFamilyID)
    
    familyMgr = GameWorld.GetFamilyManager()
    family = familyMgr.FindFamily(winFamilyID)
    if not family:
        GameWorld.Log("    »ñʤÏÉÃËÒѽâÉ¢£¡²»·¢·Å½±Àø£¡winFamilyID=%s" % winFamilyID)
        return winFamilyID
    
    notBattleRewardItemList = IpyGameDataPY.GetFuncEvalCfg("FamilyMatchOtherReward", 1) # ûÓÐÕý³£±ÈÈüµÄ½±Àø
    notBattleRewardRateList = IpyGameDataPY.GetFuncEvalCfg("FamilyMatchOtherReward", 2) # ½±Àø±ÈÀý
    
    groupID = GetBatRecGroupID(recData)
    rewardPer = notBattleRewardRateList[groupID - 1] if 1 <= groupID <= len(notBattleRewardRateList) else notBattleRewardRateList[0]
    
    playerIDList = []
    addItemList = []
    for itemID, itemCount, isBind in notBattleRewardItemList:
        addItemList.append([itemID, max(1, int(itemCount * rewardPer / 100.0)), isBind])
        
    for index in xrange(family.GetCount()):
        curMember = family.GetAt(index)
        playerIDList.append(curMember.GetPlayerID())
        
    # ϵͳ·¢·Åδ½áËãµÄ»î¶¯½±ÀøÓʼþ
    roundNum = GetBatRecRoundNum(recData)
    PlayerCompensation.SendMailByKey("FairyLeagueCompensation", playerIDList, addItemList, [roundNum, groupID])
    
    # δ½áËãµÄ»î¶¯²ÎÓë½±
    joinAwardItemList = IpyGameDataPY.GetFuncEvalCfg("FamilyMatchRankReward", 3)
    PlayerCompensation.SendMailByKey("FairyLeagueJoinReward", playerIDList, joinAwardItemList, [roundNum])
    
    GameWorld.Log("    ·¢·Åδ½áËã±ÈÈü½±Àø=roundNum=%s,groupID=%s,winFamilyID=%s,rewardPer=%s,addItemList=%s,joinAwardItemList=%s" 
                  % (roundNum, groupID, winFamilyID, rewardPer, addItemList, joinAwardItemList))
    return winFamilyID
def OnFamilyWar_Over(roundNum):
    ## ÏÉÃËÁªÈü¶ÔÕ½½áÊø´¦Àí
    
    # Ê×ÂÖ½áÊøÖ»´¦ÀíδÕý³£½áËãµÄÊ×ÂÖ±ÈÈü
    if roundNum == FamilyWarRound_First:
        warBatRecList = GameWorld.GetUniversalRecMgr().GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
        warCount = warBatRecList.Count()
        for i in xrange(warCount):
            recData = warBatRecList.At(i)
            if roundNum != GetBatRecRoundNum(recData):
                continue
            if GetBatRecWinFamilyID(recData):
                continue
            
            groupID = GetBatRecGroupID(recData)
            familyIDA = GetBatRecFamilyIDA(recData)
            familyIDB = GetBatRecFamilyIDB(recData)
            GameWorld.Log("ÏÉÃËÁªÈüϵͳ´¦Àíδ½áËãµÄ¶ÔÕ½½á¹û! roundNum=%s,groupID=%s,familyIDA=%s,familyIDB=%s" % (roundNum, groupID, familyIDA, familyIDB))
            __SetBatRecWinFamilyIDBySystem(recData, familyIDA, familyIDB, False)
            if warCount == 1:
                GameWorld.Log("ÏÉÃËÁªÈüÊ×ÂÖÖ»ÓÐÒ»³¡¶ÔÕ½£¬Ö±½ÓÖ´ÐÐ×ܽáËã!")
                __DoLogicFamilyWarAllOver()
        return
    
    # ´ÎÂÖ½áÊøÖ±½Ó×ܽáËã
    if roundNum == FamilyWarRound_Second:
        __DoLogicFamilyWarAllOver()
        
    return
def DoOnDay():
    DoLogicFamilyWar_NextWeekGroupRank()
    return
def DoLogicFamilyWar_NextWeekGroupRank():
    ''' ÏÂÖÜ·Ö×鶨¼¶
        ×îµÍ¼¶±ð×飺 ²»ÉèÖÃÁªÈü¼¶±ð, ÏÂÖÜ×îµÍ¼¶±ð×éÃûµ¥ÓÉÆäËûÎÞÁªÈü¼¶±ðÏÉÃË×ÜÕ½Á¦ÅÅÐеõ½
    '''
    GameWorld.Log("======= ÏÉÃËÁªÈüÏÂÖÜ·Ö×鶨¼¶ =======")
    # ÕâÀï²¹´¥·¢Ò»´Î£¬·ÀÖ¹×ܽáËãµÄʱºò·þÎñÆ÷Ò쳣ûÓгɹ¦½áËã
    #     »ò ´ÎÂÖûÓбÈÈüµ¼ÖÂûÓнáË㣨´ÎÂÖµÄÏÉÃ˶¼½âÉ¢Á˲ſÉÄܳöÏÖ£¬Ò»°ã²»¿ÉÄܳöÏÖ£¬¿É²»¿¼ÂÇ£¬Èç¹ûÕæ³öÏÖÁË£¬»áÔÚÖÜÁùÁ賿½áË㣩
    __DoLogicFamilyWarAllOver()
    #UpdFamilyWarRank()
    return
def UpdFamilyWarRank():
    '''¸üÐÂÏÉÃËÁªÈüÅÅÃû
    ×¢Ò⣺¸ÃÂß¼ÔÚÏÉÃËÁªÈüÖÜÆÚÖв»¿ÉÖ´ÐУ¬½öÔÚÏÂÖÜ·Ö×鶨¼¶×´Ì¬Ï¿ɸüУ¬ÓɳÌÐò¿ØÖÆ£¬Ôڻ½áÊøºó½áËãµ÷ÓÃ
    ÏÉÃËÁªÈüÐÂÒ»ÖÜÆÚ¿ªÊ¼Ê±¡¢ÏÉÃ˽âɢʱ »á´¥·¢¸ÃÂß¼
    '''
    #gameWorld = GameWorld.GetGameWorld()
    #state = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_FBFuncState % ChConfig.Def_FBMapID_FamilyWar)
    #if state != GameWorldFamilyWar.FamilyWarState_NextWeekGroupRank:
    #    GameWorld.DebugLog("·ÇÏÂÖÜ·Ö×鶨¼¶½×¶Î²»¿É¸üÐÂÏÉÃËÁªÈüÅÅÃû!")
    #    return
    
    GameWorld.Log("=== ¸üÐÂÏÉÃËÁªÈüÅÅÃû ===")
    
    familyMgr = GameWorld.GetFamilyManager()
    sortFamilyIDList = PlayerFamily.GetSortFamilyIDList()
    for rank, familyID in enumerate(sortFamilyIDList, 1):
        family = familyMgr.FindFamily(familyID)
        if not family:
            continue
        curRank = PlayerFamily.GetFamilyWarRank(family)
        if not curRank:
            break
        if curRank != rank:
            PlayerFamily.SetFamilyWarRank(family, rank)
            GameWorld.Log("    ¸üÐÂÏÉÃËÁªÈüÏÉÃËÅÅÃû: familyID=%s,curRank=%s,updRank=%s" % (family.GetID(), curRank, rank))
            
    return
def __DoLogicFamilyWarAllOver():
    ''' ÏÉÃËÈüÈ«²¿±ÈÈü½áÊøºóÂß¼
        ·Ç×î¸ß¼¶±ð×é: µÚÒ»Ãû½ú¼¶
        ·Ç×îµÍ¼¶±ð×é: ×îºóÃû½µ¼¶
        ×îµÍ¼¶±ð×飺 ²»ÉèÖÃÁªÈü¼¶±ð, ÏÂÖÜ×îµÍ¼¶±ð×éÃûµ¥ÓÉÆäËûÎÞÁªÈü¼¶±ðÏÉÃË×ÜÕ½Á¦ÅÅÐеõ½
    '''
    
    allOverDo = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_AllOver)
    if allOverDo:
        GameWorld.Log("ÒѾ´¦Àí¹ýÏÉÃËÁªÈü×ܽáË㣬²»Öظ´´¦Àí£¡")
        return
    GameWorld.Log("====== ÏÉÃËÁªÈü×ܽáË㣬´¦ÀíÏÉÃ˽ú¼¶¡¢½µ¼¶£¡ ======")
    
    Def_WinScore = {FamilyWarRound_First:10, FamilyWarRound_Second:1} # ÿÂÖ»ñʤµÃ·Ö,È·±£Ê×ÂÖ»ñʤΪʤÕß×é»ý·ÖÄÜÅÅÃû1¡¢2Ãû, °´×îÖÕ»ý·ÖËãÅÅÃû
    
    # 1. ͳ¼Æ¸÷ÏÉÃËÁªÈü×Ü»ý·Ö
    allDissFamilyIDList = []
    allGroupFamilyScoreDict = {}
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    if not warBatRecList.Count():
        GameWorld.Log("ûÓÐÏÉÃËÁªÈü±ÈÈü¼Ç¼£¬²»ÐèÒª½áË㣡")
        curRoundNum = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
        PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round, 0) # ÖØÖöÔÕ½ÂÖ´Î
        PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_AllOver, 1) # ÉèÖÃÒѾ´¦Àí¹ý×ܽáËã
        GameWorld.Log("ÖØÖÃÂÖ´ÎÐÅÏ¢£¬ÉèÖÃÒѽáË㣡curRoundNum=%s" % curRoundNum)
        return
    for i in xrange(warBatRecList.Count()):
        recData = warBatRecList.At(i)
        groupID = GetBatRecGroupID(recData)
        roundNum = GetBatRecRoundNum(recData)
        familyIDA = GetBatRecFamilyIDA(recData)
        familyIDB = GetBatRecFamilyIDB(recData)
        winFamilyID = GetBatRecWinFamilyID(recData)
        dissFamilyIDList = GetBatRecDissolutionID(recData)
        for familyID in dissFamilyIDList:
            if familyID not in allDissFamilyIDList:
                allDissFamilyIDList.append(familyID)
        if not winFamilyID:
            winFamilyID = __SetBatRecWinFamilyIDBySystem(recData, familyIDA, familyIDB, False)
            
        familyScoreA = Def_WinScore.get(roundNum, 0) if familyIDA == winFamilyID else 0
        familyScoreB = Def_WinScore.get(roundNum, 0) if familyIDB == winFamilyID else 0
        
        # ±¾×éÏÉÃËID¶ÔÓ¦µÃ·Ö
        groupFamilyScoreDict = allGroupFamilyScoreDict.get(groupID, {})
        groupFamilyScoreDict[familyIDA] = groupFamilyScoreDict.get(familyIDA, 0) + familyScoreA
        groupFamilyScoreDict[familyIDB] = groupFamilyScoreDict.get(familyIDB, 0) + familyScoreB            
        allGroupFamilyScoreDict[groupID] = groupFamilyScoreDict
        
    # 2. ÿ×éÏÉÃ˰´»ý·ÖÅÅÐòµÃ³ö×éÄÚÅÅÃû
    familyWarIDRankList = []
    groupID = FamilyWar_MaxGroupID
    for i in xrange(FamilyWar_MaxGroupID):
        groupID = FamilyWar_MaxGroupID - i
        if groupID not in allGroupFamilyScoreDict:
            continue
        groupFamilyScoreDict = allGroupFamilyScoreDict[groupID]
        groupFamilySortList = []
        for familyID, score in groupFamilyScoreDict.items():
            if familyID:
                groupFamilySortList.append([score, familyID])
        groupFamilySortList.sort(reverse=True) # °´»ý·Öµ¹ÐòÅÅ
        groupFamilyIDSortList = [groupFamily[1] for groupFamily in groupFamilySortList]
        GameWorld.Log("×éÏÉÃË»ý·ÖÅÅÃû: groupID=%s,groupFamilySortList=%s" % (groupID, groupFamilySortList))
        familyWarIDRankList += groupFamilyIDSortList
    GameWorld.Log("»ý·ÖÅÅÐòºóÏÉÃËID: %s" % familyWarIDRankList)
        
    # 3. ´¦Àí½ú¼¶¡¢½µ¼¶
    familyWarIDRankList += [0] * (FamilyWar_MaxFamilyCount - len(familyWarIDRankList)) # ²¹ÆëË÷Òý£¬·½±ãºóÃæÂß¼´¦Àí
    for i in xrange(1, FamilyWar_MaxGroupID):
        index = i * FamilyWar_GroupFamilyCount # ÏÂ×éµÚÒ»ÃûË÷Òý, ÕâÀï×î´óË÷ÒýΪ×îºóÒ»×éµÚÒ»Ãû
        preIndex = index - 1 # ÉÏ×é×îºóÒ»ÃûË÷Òý
        if not familyWarIDRankList[index]:
            GameWorld.Log("    ÏÂ×éµÚÒ»ÃûÎÞÏÉÃË£¬²»½»»»!index=%s" % index)
            continue
        # Ö±½Ó½»»»Î»Öã¨Ò»½úÒ»½µ£©
        GameWorld.Log("    ½µ¼¶ÏÉÃËË÷Òý=%s£¬½ú¼¶ÏÉÃËË÷Òý=%s" % (preIndex, index))
        familyWarIDRankList[preIndex], familyWarIDRankList[index] = familyWarIDRankList[index], familyWarIDRankList[preIndex]
    GameWorld.Log("½ú¼¶½µ¼¶ºóÏÉÃËID: %s" % familyWarIDRankList)
    
    # 4. ½ØÈ¡0Ö®ºóµÄ
    if 0 in familyWarIDRankList:
        familyWarIDRankList = familyWarIDRankList[:familyWarIDRankList.index(0)]
        GameWorld.Log("³ý0ºóÏÉÃËID: %s" % familyWarIDRankList)
    
    # 5. ½ØÈ¡µ½µ¹ÊýµÚ¶þ×飬×îºóÒ»×éÏÂÖÜÓÉÕ½Á¦¾ö¶¨
    updFamilyIDRankList = familyWarIDRankList[:(FamilyWar_MaxFamilyCount - FamilyWar_GroupFamilyCount)]
    GameWorld.Log("×îÖÕµÄÅÅÃûÏÉÃËID: %s" % familyWarIDRankList)
    GameWorld.Log("¸üеÄÅÅÃûÏÉÃËID: %s" % updFamilyIDRankList)
    GameWorld.Log("    ½âÉ¢µÄÏÉÃËID: %s" % allDissFamilyIDList)
    # ×¢Òâ: familyWarIDRankList Õâ¸öÁбíÀïµÄÏÉÃËID¿ÉÄÜÊÇÒѾ½âÉ¢µÄ£¬µ«ÊÇÔÚµ±Ç°Çé¿öÏ»¹ÐèÒªÕ¼ÓøÃÁªÈü×éµÄÃû¶î£¬Ö±µ½ÏÂÖÜ·Ö×鶨¼¶²Å±»¶¥µô
    
    # 6. ¸üÐÂÏÉÃËÆÀ¼¶
    updFamilyIDList = []
    familyMgr = GameWorld.GetFamilyManager()
    # ÏȸüÐÂÉÏÖÜÃû´ÎÓÐÁªÈüÅÅÃûµÄ£¬¿ÉÄÜÓÐЩÃû´Î±ä¶¯ÁË£¬¿ÉÄÜÓÐЩ½µ¼¶µô³öÅÅÃû
    sortFamilyIDList = PlayerFamily.GetSortFamilyIDList()
    for familyID in sortFamilyIDList:
        family = familyMgr.FindFamily(familyID)
        if not family:
            continue
        lastRank = PlayerFamily.GetFamilyWarRank(family)
        if not lastRank:
            break
        updFamilyIDList.append(familyID)
        updRank = 0 if familyID not in updFamilyIDRankList else (updFamilyIDRankList.index(familyID) + 1)
        if updRank != lastRank:
            PlayerFamily.SetFamilyWarRank(family, updRank)
        GameWorld.Log("¸üÐÂÏÉÃËÆÀ¼¶: familyID=%s,lastRank=%s,updRank=%s" % (familyID, lastRank, updRank))
        
    # ÔÙ¸üб¾ÖÜнúµÄÁªÈüÅÅÃû
    for updRank, familyID in enumerate(updFamilyIDRankList, 1):
        if familyID in updFamilyIDList:
            continue
        family = familyMgr.FindFamily(familyID)
        if not family:
            GameWorld.Log("нúÏÉÃËÆÀ¼¶, ÏÉÃËÒѽâÉ¢!familyID=%s,updRank=%s" % (familyID, updRank))
            continue
        lastRank = 0
        PlayerFamily.SetFamilyWarRank(family, updRank)
        GameWorld.Log("нúÏÉÃËÆÀ¼¶: familyID=%s,lastRank=%s,updRank=%s" % (familyID, lastRank, updRank))
        
    # Ç¿ÖÆ¸üÐÂÏÉÃËÅÅÐò
    PlayerFamily.DoFamilySort()
    
    if familyWarIDRankList:
        UpdFamilyWarChampion(familyWarIDRankList[0])
        GiveFamilyWinRankAuctionReward(familyWarIDRankList)
    
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round, 0) # ÖØÖöÔÕ½ÂÖ´Î
    PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_AllOver, 1) # ÉèÖÃÒѾ´¦Àí¹ý×ܽáËã
    
    UpdFamilyWarRank() # ¸ÄΪ±ÈÈü½áÊøºóĬÈϸüÐÂÁªÈüÅÅÃû
    return
def UpdFamilyWarChampion(championFamilyID):
    ## ¸üйھüÐÅÏ¢, ¹Ú¾ü¿ÉÄÜÒѽâÉ¢
    family = GameWorld.GetFamilyManager().FindFamily(championFamilyID)
    championRecData = GetFamilyWarChampionRecData()
    lastChampionFamilyID = GetFWChampionFamilyID(championRecData)
    championFamilyName = GetFWChampionFamilyName(championRecData)
    GameWorld.Log("ÉÏÖܹھüÏÉÃËID: %s" % lastChampionFamilyID)
    GameWorld.Log("±¾ÖܹھüÏÉÃËID: %s" % championFamilyID)
    winCount = GetFWChampionWinCount(championRecData)
    rewardWinCount = winCount + 1
    GiveFamilyWinCountAuctionReward(championFamilyID, rewardWinCount)
    if lastChampionFamilyID == championFamilyID:
        winCount += 1
        SetFWChampionWinCount(championRecData, winCount)
        GameWorld.Log("    ¸üÐÂÁ¬Ê¤: %s" % winCount)
        #AllotWinRewardBySystem(championRecData, False)
    else:
        #AllotWinRewardBySystem(championRecData, True)
        SetFWChampionFamilyID(championRecData, championFamilyID)
        SetFWChampionWinCount(championRecData, 1)
        SetFWChampionWinRewardAllot(championRecData, 0)
        GameWorld.Log("    ¹Ú¾ü±ä¸ü!")
        winRewardStartCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 2) # ÆðʼÁ¬Ê¤½±Àø´ÎÊý
        winRewardSpaceCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 3) # Á¬Ê¤½±Àø¼ä¸ô´ÎÊý
        endWinCount = winCount + 1
        if endWinCount == winRewardStartCount or (endWinCount > winRewardStartCount and (endWinCount - winRewardStartCount) % winRewardSpaceCount == 0):
            SetFWChampionEndWinCount(championRecData, endWinCount)
            GameWorld.Log("    ÖÕÖ¹¶Ô·½Á¬Ê¤! endWinCount=%s" % endWinCount)
        # ¸üÐÂÏÉÃËÐÅÏ¢
        if family:
            championFamilyName = family.GetName()
            SetFWChampionLeaderID(championRecData, family.GetLeaderID())
            SetFWChampionFamilyName(championRecData, championFamilyName)
        else:
            GameWorld.Log("    ¹Ú¾üÏÉÃ˲»´æÔÚ»òÒѾ½âÉ¢ÁË!")
            
        # ֪ͨµØÍ¼¹Ú¾ü±ä¸ü
        GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_ChampionFamilyID, championFamilyID)
        # Ö÷¶¯¹ã²¥Ò»´Î¿Í»§¶Ë
        PlayerUniversalGameRec.SendUniversalGameRecSingle(None, championRecData)
        
    # ·¢ËÍÍõÕßÏÉÃ˺ì°ü
    redPackID = IpyGameDataPY.GetFuncCfg("FamilyMatchOtherReward", 3)
    if redPackID and family:
        PlayerFamilyRedPacket.CreatNewFamilyRedPacket(family, family.GetLeaderID(), redPackID)
        
    # ±¾ÂÖÏÉÃËÁªÈüÒѽáÊø£¬%s0ÏÉÃ˰εÃÍ·³ï£¬³ÉΪÍõÕßÏÉÃË
    if championFamilyName:
        PlayerControl.WorldNotify(0, "FamilyMatchSecondSessionEnd", [championFamilyName])
    return
def GiveFamilyWinCountAuctionReward(familyID, rewardWinCount):
    ## ¸øÏÉÃËÁ¬Ê¤ÏÉÃËÅÄÆ·½±Àø
    
    winRewardStartCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 2) # ÆðʼÁ¬Ê¤½±Àø´ÎÊý
    winRewardSpaceCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 3) # Á¬Ê¤½±Àø¼ä¸ô´ÎÊý
    
    rewardIndex = -1
    
    if rewardWinCount == winRewardStartCount:
        rewardIndex = 0
    elif rewardWinCount > winRewardStartCount:
        winCountValue = rewardWinCount - winRewardStartCount
        if winCountValue % winRewardSpaceCount == 0:
            rewardIndex = winCountValue / winRewardSpaceCount
            
    if rewardIndex == -1:
        GameWorld.Log("²»ÐèÒª·¢·ÅÁ¬Ê¤ÏÉÃËÅÄÆ·½±Àø: familyID=%s,rewardWinCount=%s" % (familyID, rewardWinCount))
        return
    
    winRewardLoopList = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 4) # Á¬Ê¤ÏÉÃËÅÄÆ·Ñ»·½±Àø[[[ÅÄÆ·ID,¸öÊý], ...], ...]
    loopIndex = rewardIndex % len(winRewardLoopList)
    familyAuctionItemList = winRewardLoopList[loopIndex]
    family = GameWorld.GetFamilyManager().FindFamily(familyID)
    if not family:
        return
    
    familyAllPlayerIDList = []
    familyPlayerIDList = []
    for i in xrange(family.GetCount()):
        member = family.GetAt(i)
        memPlayerID = member.GetPlayerID()
        if memPlayerID not in PyGameData.g_familyWarMemDict:
            continue
        familyAllPlayerIDList.append(memPlayerID)
        recData = PyGameData.g_familyWarMemDict[memPlayerID]
        if GetFWMemFamilyID(recData) != familyID:
            continue
        if not GetFWMemIsJoin(recData):
            continue
        familyPlayerIDList.append(memPlayerID)
    if not familyPlayerIDList:
        familyPlayerIDList = familyAllPlayerIDList
        GameWorld.Log("Á¬Ê¤Ã»ÓÐÈ˲ÎÈü£¬ÊÕÒæËãÏÉÃËËùÓÐÈ˵ģ¡familyID=%s,familyAllPlayerIDList=%s" % (familyID, familyAllPlayerIDList))
        
    familyAuctionItemDict = {} # {ÏÉÃËID:[[ÏíÊÜÊÕÒæµÄ³ÉÔ±ID, ...], [[ÅÄÆ·ID,¸öÊý], [ÅÄÆ·ID,¸öÊý,ÊÇ·ñÅÄÆ·], ...]], ...}
    familyAuctionItemDict[familyID] = [familyPlayerIDList, familyAuctionItemList]
    GameWorld.Log("·¢·ÅÁ¬Ê¤ÏÉÃËÅÄÆ·½±Àø: familyID=%s,rewardWinCount=%s,rewardIndex=%s,loopIndex=%s" 
                  % (familyID, rewardWinCount, rewardIndex, loopIndex))
    GameWorld.Log("    familyPlayerIDList=%s" % familyPlayerIDList)
    GameWorld.Log("    familyAuctionItemList=%s" % familyAuctionItemList)
    AuctionHouse.DoAddFamilyAuctionItem(ChConfig.Def_FBMapID_FamilyWar, familyAuctionItemDict)
    return
def GiveFamilyWinRankAuctionReward(familyWarIDRankList):
    ## ¸øÏÉÃËÅÅÃûÏÉÃËÅÄÆ·½±Àø
        
    warWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_StartWorldLV)
    rewardWorldLV = 0
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetFamilyWarRankAwardCount()):
        ipyData = ipyDataMgr.GetFamilyWarRankAwardByIndex(index)
        cfgWorldLV = ipyData.GetWarWorldLV()
        if warWorldLV <= cfgWorldLV:
            rewardWorldLV = cfgWorldLV
            break
        elif warWorldLV > cfgWorldLV:
            rewardWorldLV = cfgWorldLV
    GameWorld.Log("·¢·ÅÅÅÃûÏÉÃËÅÄÆ·½±Àø: warWorldLV=%s, rewardWorldLV=%s, familyWarIDRankList=%s" % (warWorldLV, rewardWorldLV, familyWarIDRankList))
    
    rewardIpyDataList = IpyGameDataPY.GetIpyGameDataList("FamilyWarRankAward", rewardWorldLV)
    if not rewardIpyDataList:
        GameWorld.ErrLog("ÕÒ²»µ½ÏÉÃËÅÅÃû¶ÔÓ¦ÊÀ½çµÈ¼¶½±Àø!")
        return
    
    cfgRankKey = 1
    cfgRankAuctionItemDict = {}
    for ipyData in rewardIpyDataList:
        warRank = ipyData.GetWarRank()
        auctionItemList = ipyData.GetRankAuctionItem()
        for rank in range(cfgRankKey, warRank + 1):
            cfgRankAuctionItemDict[rank] = auctionItemList
        cfgRankKey = warRank + 1
        
    GameWorld.Log("¶ÔÓ¦ÊÀ½çµÈ¼¶½±Àø: rewardWorldLV=%s, %s" % (rewardWorldLV, cfgRankAuctionItemDict))
        
    familyAuctionItemDict = {} # {ÏÉÃËID:[[ÏíÊÜÊÕÒæµÄ³ÉÔ±ID, ...], [[ÅÄÆ·ID,¸öÊý], [ÅÄÆ·ID,¸öÊý,ÊÇ·ñÅÄÆ·], ...]], ...}
    for rank, familyID in enumerate(familyWarIDRankList, 1):
        if rank not in cfgRankAuctionItemDict:            
            GameWorld.Log("    rank=%s,familyID=%s,¸ÃÃû´ÎûÓÐÕÒµ½½±Àø!" % (rank, familyID))
            continue
        
        family = GameWorld.GetFamilyManager().FindFamily(familyID)
        if not family:
            GameWorld.Log("    rank=%s,familyID=%s,ÏÉÃ˲»´æÔÚ!" % (rank, familyID))
            continue
        
        familyAllPlayerIDList = []
        familyPlayerIDList = []
        for i in xrange(family.GetCount()):
            member = family.GetAt(i)
            memPlayerID = member.GetPlayerID()
            if memPlayerID not in PyGameData.g_familyWarMemDict:
                continue
            familyAllPlayerIDList.append(memPlayerID)
            recData = PyGameData.g_familyWarMemDict[memPlayerID]
            if GetFWMemFamilyID(recData) != familyID:
                continue
            if not GetFWMemIsJoin(recData):
                continue
            familyPlayerIDList.append(memPlayerID)
        if not familyPlayerIDList:
            familyPlayerIDList = familyAllPlayerIDList
            GameWorld.Log("    ÅÅÃûûÓÐÈ˲ÎÈü£¬ÊÕÒæËãÏÉÃËËùÓÐÈ˵ģ¡familyID=%s,familyAllPlayerIDList=%s" % (familyID, familyAllPlayerIDList))
            
        familyAuctionItemList = cfgRankAuctionItemDict[rank]
        familyAuctionItemDict[familyID] = [familyPlayerIDList, familyAuctionItemList]
        GameWorld.Log("    rank=%s,familyID=%s,familyPlayerIDList=%s,familyAuctionItemList=%s" 
                      % (rank, familyID, familyPlayerIDList, familyAuctionItemList))
        
    AuctionHouse.DoAddFamilyAuctionItem(ChConfig.Def_FBMapID_FamilyWar, familyAuctionItemDict)
    return
def GetFamilyWarChampionRecData():
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    championRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarChampion)
    if championRecList.Count():
        return championRecList.At(0)
    return championRecList.AddRec()
def AllotWinRewardBySystem(championRecData, isAll):
    ## ϵͳ×Ô¶¯·ÖÅäÏÉÃËδ·ÖÅäµÄÁ¬Ê¤½±Àø
    ## µ¥ºÅ 7195 2019-06-10 È¥³ý·ÖÅä½±Àø£¬Á¬Ê¤¸ÄΪÅÄÆ·½±Àø
    return
    
#    familyID = GetFWChampionFamilyID(championRecData)
#    leaderID = GetFWChampionLeaderID(championRecData)
#    winCount = GetFWChampionWinCount(championRecData) # µ±Ç°Á¬Ê¤´ÎÊý
#    lastAllotWinCount = GetFWChampionWinRewardAllot(championRecData) # ÉÏ´ÎÒÑ·ÖÅäµÄÁ¬Ê¤½±Àø´ÎÊý
#    endWinCount = GetFWChampionEndWinCount(championRecData) # ÖÕ½á¶ÔÊÖµÄÁ¬Ê¤´ÎÊý
#    
#    winRewardItemList = IpyGameDataPY.GetFuncEvalCfg("FamilyMatchLianWinReward", 1) # Á¬Ê¤½±Àø
#    winRewardStartCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 2) # ÆðʼÁ¬Ê¤½±Àø´ÎÊý
#    winRewardSpaceCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 3) # Á¬Ê¤½±Àø¼ä¸ô´ÎÊý
#    if not winRewardItemList or not winRewardStartCount or not winRewardSpaceCount:
#        return
#    
#    updAllotWinCount = 0 # ¸üеÄÒÑ·ÖÅäµ½µÄÁ¬Ê¤´ÎÊý
#    startRewardWinCount = winRewardStartCount if not lastAllotWinCount else (lastAllotWinCount + winRewardSpaceCount) # Ï´ÎÁ¬Ê¤½±Àø´ÎÊý
#    sysAllotWinCountList = range(startRewardWinCount, winCount + 1, winRewardSpaceCount)
#    isAllotEndWinCount = (endWinCount and (isAll or sysAllotWinCountList))
#    
#    if not isAll and sysAllotWinCountList:
#        sysAllotWinCountList = sysAllotWinCountList[:-1] # ±£ÁôÒ»¸ö¿ÉÊÖ¶¯·ÖÅä, ÆäÓà×Ô¶¯·ÖÅä
#    if sysAllotWinCountList:
#        updAllotWinCount = sysAllotWinCountList[-1]
#        
#    sysAllotCount = len(sysAllotWinCountList) # ϵͳ×Ô¶¯·¢·ÅµÄ½±Àø´ÎÊý
#    if isAllotEndWinCount:
#        sysAllotCount += 1
#        
#    if sysAllotCount <= 0:
#        #GameWorld.Log("ÎÞÐè×Ô¶¯·ÖÅä½±Àø£¡Éϴν±ÀøÁ¬Ê¤´ÎÊý=%s,µ±Ç°Á¬Ê¤Êý=%s,ÖÕ½áÁ¬Ê¤=%s,isAll=%s,sysAllotWinCountList=%s" 
#        #              % (lastAllotWinCount, winCount, endWinCount, isAll, sysAllotWinCountList))
#        return
#    
#    if sysAllotCount > 1:
#        winRewardItemList = copy.deepcopy(winRewardItemList)
#        for itemInfo in winRewardItemList:
#            itemInfo[1] *= sysAllotCount
#    GameWorld.Log("ϵͳ×Ô¶¯·ÖÅäÁ¬Ê¤½±Àø¸øÃËÖ÷£¡Éϴν±ÀøÁ¬Ê¤´ÎÊý=%s,µ±Ç°Á¬Ê¤Êý=%s,ÖÕ½áÁ¬Ê¤=%s,·ÖÅä´ÎÊý=%s,ÎïÆ·=%s,isAll=%s,familyID=%s,leaderID=%s" 
#                  % (lastAllotWinCount, winCount, endWinCount, sysAllotCount, winRewardItemList, isAll, familyID, leaderID))
#    if sysAllotWinCountList:
#        GameWorld.Log("    sysAllotWinCountList=%s" % sysAllotWinCountList)
#    if endWinCount:
#        GameWorld.Log("    ÖØÖÃÒÑ·ÖÅäÖÕ½á¶ÔÊÖÁ¬Ê¤´ÎÊý½±Àø!")
#        SetFWChampionEndWinCount(championRecData, 0)
#    if updAllotWinCount:
#        GameWorld.Log("    ¸üÐÂÒÑ·ÖÅäµ½µÄÁ¬Ê¤´ÎÊý: %s" % updAllotWinCount)
#        SetFWChampionWinRewardAllot(championRecData, updAllotWinCount)
#    PlayerCompensation.SendMailByKey("FamilyMatchWinAllotMail2", [leaderID], winRewardItemList)
#    GameWorld.Log("    -----------------------")
#    return
#// A4 10 ÏÉÃËÁªÈüÁ¬Ê¤½±Àø·ÖÅä #tagCGFamilyWarWinRewardAllot
#
#struct     tagCGFamilyWarWinRewardAllot
#{
#    tagHead        Head;
#    DWORD        MemPlayerID;    //·ÖÅ䏸µÄÏÉÃ˳ÉÔ±Íæ¼ÒID
#};
def OnFamilyWarWinRewardAllot(index, clientData, tick):
    # µ¥ºÅ 7195 2019-06-10 È¥³ý·ÖÅä½±Àø£¬Á¬Ê¤¸ÄΪÅÄÆ·½±Àø
    return
#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
#    memPlayerID = clientData.MemPlayerID
#    playerID = curPlayer.GetPlayerID()
#    curFamily = curPlayer.GetFamily()
#    if curFamily == None:
#        return
#    curMember = curFamily.FindMember(playerID)
#    if curMember == None:
#        return
#    if curMember.GetFamilyLV() != IPY_GameServer.fmlLeader:
#        GameWorld.Log("²»ÊÇÃËÖ÷£¬²»ÄÜ·ÖÅäÁ¬Ê¤½±Àø£¡", playerID)
#        return
#    
#    familyID = curFamily.GetID()
#    curTagMember = curFamily.FindMember(memPlayerID)
#    if curTagMember == None:
#        GameWorld.Log("ÏÉÃËûÓиóÉÔ±£¬ÎÞ·¨·ÖÅäÁ¬Ê¤½±Àø£¡familyID=%s,memPlayerID=%s" % (familyID, memPlayerID), playerID)
#        return
#    
#    championRecData = GetFamilyWarChampionRecData()
#    championFamilyID = GetFWChampionFamilyID(championRecData)
#    if familyID != championFamilyID:
#        GameWorld.Log("·ÇÍõÕßÏÉÃË£¬ÎÞ·¨·ÖÅäÁ¬Ê¤½±Àø£¡championFamilyID=%s,familyID=%s" % (championFamilyID, familyID), playerID)
#        return
#    
#    endWinCount = GetFWChampionEndWinCount(championRecData) # ÖÕ½á¶ÔÊÖµÄÁ¬Ê¤´ÎÊý
#    if endWinCount:
#        SetFWChampionEndWinCount(championRecData, 0)
#        GameWorld.Log("·ÖÅäÖÕ½áÏÉÃËÁ¬Ê¤½±Àø!familyID=%s,endWinCount=%s" % (familyID, endWinCount), playerID)
#        
#    else:
#        winCount = GetFWChampionWinCount(championRecData) # µ±Ç°Á¬Ê¤´ÎÊý
#        lastAllotWinCount = GetFWChampionWinRewardAllot(championRecData) # ÉÏ´ÎÒÑ·ÖÅäµÄÁ¬Ê¤½±Àø´ÎÊý
#        
#        winRewardStartCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 2) # ÆðʼÁ¬Ê¤½±Àø´ÎÊý
#        winRewardSpaceCount = IpyGameDataPY.GetFuncCfg("FamilyMatchLianWinReward", 3) # Á¬Ê¤½±Àø¼ä¸ô´ÎÊý
#        nextRewardWinCount = winRewardStartCount if not lastAllotWinCount else (lastAllotWinCount + winRewardSpaceCount) # Ï´ÎÁ¬Ê¤½±Àø´ÎÊý
#        if winCount < nextRewardWinCount:
#            GameWorld.Log("Á¬Ê¤´ÎÊý²»×㣬ÎÞ·¨·ÖÅäÁ¬Ê¤½±Àø£¡ÒÑ·ÖÅäÁ¬Ê¤½±Àø´ÎÊý=%s,Ï´ÎÁ¬Ê¤½±Àø´ÎÊý(%s) > µ±Ç°Á¬Ê¤´ÎÊý(%s)" 
#                          % (lastAllotWinCount, nextRewardWinCount, winCount), playerID)
#            return
#        SetFWChampionWinRewardAllot(championRecData, nextRewardWinCount)
#        GameWorld.Log("·ÖÅäÏÉÃËÁ¬Ê¤½±Àø!familyID=%s,·ÖÅäÁ¬Ê¤Êý=%s" % (familyID, nextRewardWinCount), playerID)
#        
#    winRewardItemList = IpyGameDataPY.GetFuncEvalCfg("FamilyMatchLianWinReward", 1) # Á¬Ê¤½±Àø
#    PlayerCompensation.SendMailByKey("FamilyMatchWinAllotMail1", [memPlayerID], winRewardItemList)
#    PlayerUniversalGameRec.SendUniversalGameRecSingle(curPlayer, championRecData) # ͬ²½¸ø¸ÃÍæ¼Ò
#    
#    # %s0ÏÉÃËÃËÖ÷½«Á¬Ê¤½±Àø·ÖÅ䏸%s2£¬Éñ±ø½µÊÀ
#    notifyItemID = winRewardItemList[0][0]
#    PlayerControl.WorldNotify(0, "FamilyMatchLianWinReward", [curFamily.GetName(), notifyItemID, curTagMember.GetName()])
#    return
def MapServer_FamilyWarOver(msgList):
    ## µØÍ¼ÏÉÃËÕ½½áÊø
    familyIDA, familyIDB, winFamilyID, isFinalMatch = msgList
    roundNum = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_Round)
    GameWorld.Log("ÊÕµ½µØÍ¼Í¬²½µÄÏÉÃËÁªÈü½áÊøÊý¾Ý: roundNum=%s,familyIDA=%s,familyIDB=%s,winFamilyID=%s,isFinalMatch=%s" 
                  % (roundNum, familyIDA, familyIDB, winFamilyID, isFinalMatch))
    if roundNum not in [FamilyWarRound_First, FamilyWarRound_Second]:
        return
    
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    warBatRecList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    for i in xrange(warBatRecList.Count()):
        recData = warBatRecList.At(i)
        if roundNum != GetBatRecRoundNum(recData):
            continue
        if familyIDA == GetBatRecFamilyIDA(recData) and familyIDB == GetBatRecFamilyIDB(recData):
            SetBatRecWinFamilyID(recData, winFamilyID)
            GameWorld.Log("    ¸üлñʤÏÉÃËID: i=%s,winFamilyID=%s" % (i, winFamilyID))
            break
    GameWorld.Log("    PyGameData.g_familyWarFightingIDList=%s" % PyGameData.g_familyWarFightingIDList)
    if familyIDA in PyGameData.g_familyWarFightingIDList:
        PyGameData.g_familyWarFightingIDList.remove(familyIDA)
    if familyIDB in PyGameData.g_familyWarFightingIDList:
        PyGameData.g_familyWarFightingIDList.remove(familyIDB)
    GameWorld.Log("    PyGameData.g_familyWarFightingIDList=%s" % PyGameData.g_familyWarFightingIDList)
    
    PlayerUniversalGameRec.SendUniversalGameRecInfo(None, ShareDefine.Def_UniversalGameRecType_FamilyWarBattle)
    
    if roundNum == FamilyWarRound_First and not PyGameData.g_familyWarFightingIDList and not isFinalMatch:
        # ±¾³¡ÏÉÃËÁªÈüÒѽáÊø£¬ÏÂÒ»³¡½«ÓÚÖÜÎå21£º00¾ÙÐÐ
        PlayerControl.WorldNotify(0, "FamilyMatchFirstSessionEnd")
        
    # ´ÎÂÖ ÇÒ ËùÓÐÕ½¶·ÖеÄÏÉÃ˶¼ÒѽáÊø
    # Ê×ÂÖ ÇÒ ÊÇ×îÖÕ¾öÈü³¡µÄ, ÕâÖÖÇé¿ö½öÔÚÖ»ÓÐÁ½¸öÏÉÃ˵ÄÇé¿ö£¬Ö»´òÒ»³¡¾Í½áÊøÁË£¬´óÓÚ2¸öÏÉÃ˵ÄÒ»¶¨»á´òµ½´ÎÂÖ
    if (roundNum == FamilyWarRound_Second and not PyGameData.g_familyWarFightingIDList) \
        or (roundNum == FamilyWarRound_First and isFinalMatch):
        __DoLogicFamilyWarAllOver()
        
    return
def Sync_FamilyWarInfo(curPlayer=None):
    warInfo = ChPyNetSendPack.tagGCFamilyWarInfo()
    warInfo.WorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_FamilyWar_StartWorldLV)
    NetPackCommon.SendPackByPlayer(warInfo, curPlayer)
    return