#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GameWorldLogic.FBProcess.GameLogic_Qunying
#
# @todo:ȺӢ°ñ
# @author hxp
# @date 2026-03-11
# @version 1.0
#
# ÏêϸÃèÊö: ȺӢ°ñ
#
#-------------------------------------------------------------------------------
#"""Version = 2026-03-11 19:00"""
#-------------------------------------------------------------------------------

import DBDataMgr
import GameWorld
import TurnAttack
import ShareDefine
import PlayerControl
import IpyGameDataPY
import PlayerBillboard
import PlayerViewCache
import ChPyNetSendPack
import NetPackCommon
import ItemControler
import GameFuncComm
import PyGameData
import FBCommon
import ChConfig

import random
import time

# ¼Ç¼¹¥»÷ÀàÐÍ
RecAtkType_Atk = 1 # ·¢Æð¹¥»÷
RecAtkType_Def = 2 # ±»¹¥»÷µÄ

def GetRecAtkType(recData): return recData.GetValue2() # ¹¥»÷ÀàÐÍ 1-·¢Æð¹¥»÷µÄ£¬2-±»¹¥»÷µÄ
def SetRecAtkType(recData, atkType): return recData.SetValue2(atkType)
def GetRecTagPlayerID(recData): return recData.GetValue3() # Ïà¶Ô¹¥»÷ÀàÐ͵ÄÄ¿±êÍæ¼ÒID
def SetRecTagPlayerID(recData, tagPlayerID): return recData.SetValue3(tagPlayerID)
def GetRecIsWin(recData): return recData.GetValue4() # ÊÇ·ñ»ñʤ 1-»ñʤ£»2-ʧ°Ü
def SetRecIsWin(recData, isWin): return recData.SetValue4(1 if isWin else 0)
def GetRecFace(recData): return recData.GetValue5() # Ä¿±êÍ·Ïñ
def SetRecFace(recData, face): return recData.SetValue5(face)
def GetRecFacePic(recData): return recData.GetValue6()
def SetRecFacePic(recData, facePic): return recData.SetValue6(facePic)
def GetRecRealmLV(recData): return recData.GetValue7()
def SetRecRealmLV(recData, realmLV): return recData.SetValue7(realmLV)
def GetRecLV(recData): return recData.GetValue8()
def SetRecLV(recData, tagLV): return recData.SetValue8(tagLV)
#SetUserData Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î

def OnWeek():
    serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
    serverDayNeed = IpyGameDataPY.GetFuncCfg("QunyingSet", 1)
    if serverDayNeed and serverDay < serverDayNeed:
        GameWorld.DebugLog("¿ª·þÌì²»×ã±¾Öܲ»ÖØÖÃȺӢ°ñ! serverDay=%s < %s" % (serverDay, serverDayNeed))
        return
    DoQunyingReset()
    return

def OnDay():
    billboardAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 1, {})
    PlayerBillboard.DoGiveBillboardAwardByMail(ShareDefine.Def_BT_Qunying, "QunyingDay", billboardAwardDict, "QunyingDay", isClearData=False)
    return

def OnServerStart():
    __fillRobot()
    return

def DoQunyingReset():
    ''' Èü¼¾ÖØÖÃ
    '''
    GameWorld.Log("=============== ÖØÖÃȺӢ°ñ ===============")
    
    PyGameData.g_qunyingPlayerMatchDict = {}
    
    # ½áËãÉÏÈü¼¾ÅÅÐн±Àø
    billboardAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 2, {})
    PlayerBillboard.DoGiveBillboardAwardByMail(ShareDefine.Def_BT_Qunying, "QunyingWeek", billboardAwardDict, "QunyingWeek", isClearData=False)
    
    # ÖØÖÃÅÅÐаñ
    DBDataMgr.GetBillboardMgr().RemoveBillboard(ShareDefine.Def_BT_Qunying)
    __fillRobot()
    
    GameWorld.Log("==========================================")
    return True

def __fillRobot():
    ## Ìî³äÂú»úÆ÷ÈË
    billboardMgr = DBDataMgr.GetBillboardMgr()
    billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
    maxCount = billBoard.GetMaxCount() # »úÆ÷ÈËÌî³äÊýĬÈÏʹÓðñµ¥×î´óÊý
    
    robotFPSortList = PlayerViewCache.GetRobotFightPowerSortList(ChConfig.RobotTempNum_Qunying)
    robotDict = {} # {(rankA, rankB):[robotID], ...}
    for _, robotID in robotFPSortList:
        robotIpyData = IpyGameDataPY.GetIpyGameData("Robot", robotID)
        if not robotIpyData:
            continue
        tempValue1 = robotIpyData.GetTempValue1()
        tempValue2 = robotIpyData.GetTempValue2()
        rankKey = (tempValue1, tempValue2)
        if rankKey not in robotDict:
            robotDict[rankKey] = []
        robotList = robotDict[rankKey]
        robotList.append(robotIpyData.GetID())
        
    layerRobotIDList = []
    robotKeyList = robotDict.keys()
    robotKeyList.sort() # °´Ãû´ÎÅÅÐò´¦Àí
    for robotKey in robotKeyList:
        rankA, rankB = robotKey
        robotIDList = robotDict[robotKey]
        random.shuffle(robotIDList)
        robotCnt = len(robotIDList)
        needRobotCnt = rankB - rankA + 1
        for _ in range(needRobotCnt / robotCnt):
            layerRobotIDList += robotIDList
        for index in range(needRobotCnt % robotCnt):
            layerRobotIDList.append(robotIDList[index])
    layerRobotIDList = layerRobotIDList[:maxCount]
    GameWorld.DebugLog("Ìî³äȺӢ°ñ»úÆ÷ÈË: maxCount=%s,fillRobotIDLen=%s" % (maxCount, len(layerRobotIDList)))
    billBoard.SetOrderRuleByLayer(layerRobotIDList)
    return

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

def DoQunyingOpen(curPlayer):
    storeMax = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 1)
    PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, storeMax, "QunyingOpen")
    Sync_QunyingInfo(curPlayer) # ¿ªÆô¹¦ÄÜ
    return

def OnFBPlayerOnWeek(curPlayer):
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Qunying):
        return
    serverDay = DBDataMgr.GetEventTrigMgr().GetValue(ShareDefine.Def_ServerDay) + 1
    serverDayNeed = IpyGameDataPY.GetFuncCfg("QunyingSet", 1)
    # Íæ¼ÒÖØÖÃÓиöÎÊÌ⣬Íæ¼ÒµÄ¹ýÖܲ¢²»Ò»¶¨ÊÇÖÜÒ»´¥·¢£¬¾ßÌå¿´Íæ¼ÒʲôʱºòµÇ¼
    # ÄÇô¿ÉÄÜ´æÔÚÖܶþÍæ¼Ò²ÅµÇ¼£¬È»ºóÂú×ãÁËÖØÖÃÌõ¼þ£¬µ¼Ö´¥·¢ÁËÍæ¼Ò¸öÈ˵ÄÈü¼¾ÖØÖÃ
    # Ä¿Ç°Ö»ÓÐˢдÎÊýÐèÒªÖØÖã¬ÔÝʱ²»¿¼ÂÇÕâ¸öÎÊÌ⣬ÕâÖÖÇé¿öÒ»°ãÖ»ÓÐзþ²Å¿ÉÄܳöÏÖ
    # ¡¾×¢¡¿ÈçÖ®ºóÓÐÐèÒªÖØÖñȽÏÑϽ÷µÄÊý¾Ý£¬ÔòÐèÒª°´Èü¼¾ID¶Ô±È²»Ò»Ñù²ÅÄÜÖØÖÃ
    if serverDayNeed and serverDay < serverDayNeed:
        GameWorld.DebugLog("¿ª·þÌì²»×ã±¾Öܲ»ÖØÖÃÍæ¼ÒȺӢ°ñ! serverDay=%s < %s" % (serverDay, serverDayNeed), curPlayer.GetPlayerID())
        return
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRefreshCnt, 0)
    Sync_QunyingInfo(curPlayer) # Èü¼¾ÖØÖÃ
    return

def OnFBPlayerOnLogin(curPlayer):
    if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Qunying):
        return
    Sync_QunyingInfo(curPlayer) # 怬
    return

def __checkAtkQunyingPlayer(curPlayer, tagID, tagRank):
    '''¼ì²é¿É·ñ¹¥»÷Ä¿±ê
    '''
    playerID = curPlayer.GetPlayerID()
    if not tagID or playerID == tagID:
        return
    
    matchRankList = PyGameData.g_qunyingPlayerMatchDict.get(playerID, [])
    if tagRank not in matchRankList:
        GameWorld.DebugLog("ȺӢ°ñ²»¿É¹¥»÷²»ÔÚÆ¥ÅäÁбíÀïµÄÄ¿±êÃû´Î! tagID=%s not in matchRankList=%s" % (tagID, matchRankList), playerID)
        return
    
    # ÑéÖ¤Ãû´ÎÊÇ·ñ»¹ÓëÇ°¶ËµÄÒ»ÖÂ
    billboardMgr = DBDataMgr.GetBillboardMgr()
    billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
    if not billBoard:
        return
    layerIDList = billBoard.GetLayerIDList()
    
    tagIndex = tagRank - 1
    tagIDNow = 0 
    if 0 <= tagIndex < len(layerIDList):
        tagIDNow = layerIDList[tagIndex]
    if tagID != tagIDNow:
        GameWorld.DebugLog("ȺӢ°ñ¹¥»÷ʱĿ±êÃû´ÎÍæ¼ÒID²»Ò»ÖÂ! tagRank=%s,tagID=%s != tagIDNow=%s" % (tagRank, tagID, tagIDNow), playerID)
        PlayerControl.NotifyCode(curPlayer, "QunyingTagRankIDErr") # Ä¿±êÍæ¼ÒÃû´ÎÒѸıä
        DoQunyingMatchRefresh(curPlayer, True, isSys=True)
        return
    
    return True

def OnTurnFightRequest(curPlayer, mapID, funcLineID, tagType, tagID, valueList):
    ## »ØºÏÕ½¶·ÇëÇó 
    
    if not valueList:
        return
    
    tagRank = valueList[0] # Ä¿±êÃû´Î
    quickCnt = valueList[1] if len(valueList) > 1 else 0 # ËÙÕ½´ÎÊý
    
    # ËÙÕ½
    if quickCnt > 0:
        __doQuickFight(curPlayer, mapID, tagID, quickCnt)
        return
    
    if not __checkAtkQunyingPlayer(curPlayer, tagID, tagRank):
        return
    
    if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, 1):
        return
    
    return True, funcLineID

def __doQuickFight(curPlayer, mapID, tagID, quickCnt):
    '''Ö´ÐÐËÙÕ½£¬±Øʤ¡¢Ö»¸ø¹Ì¶¨Õ½¶·½±Àø£¬Ãû´Î²»±ä
    '''
    GameWorld.DebugLog("ȺӢ°ñËÙÕ½: tagID=%s,quickCnt=%s" % (tagID, quickCnt))
    if quickCnt <= 0:
        return
    
    if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, quickCnt, "Qunying"):
        return
    
    awardItemDict = {}
    for item in IpyGameDataPY.GetFuncEvalCfg("QunyingChallenge", 3):
        itemID, itemCount = item[:2]
        awardItemDict[itemID] = awardItemDict.get(itemID, 0) + itemCount * quickCnt
    awardItemList = [[itemID, itemCount] for itemID, itemCount in awardItemDict.items()]
    
    ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["Qunying", False, {}], isNotifyAward=False)
    
    lineID = 0
    isPass = 1
    jsonItemList = []
    for itemInfo in awardItemList:
        itemDict = {"ItemID":itemInfo[0], "Count":itemInfo[1]}
        jsonItemList.append(itemDict)
    overDict = {FBCommon.Over_itemInfo:jsonItemList, FBCommon.Over_isSweep:1, "tagID":tagID, "quickCnt":quickCnt}
    FBCommon.NotifyFBOver(curPlayer, mapID, lineID, isPass, overDict)
    return

def OnTurnFightAward(curPlayer, guid, mapID, funcLineID, winFaction, statMsg, dateStr, reqData, awardDict):
    ## »ØºÏÕ½¶·½áËã½±Àø
    if not curPlayer:
        return
    
    playerID = curPlayer.GetPlayerID()
    tagPlayerID = reqData[1]
    valueList = reqData[2]
    tagRank = valueList[0] # Ä¿±êÃû´Î
    isWin = winFaction == ChConfig.Def_FactionA
    
    GameWorld.DebugLog("½áËãȺӢ°ñÕ½¶·! isWin=%s,tagPlayerID=%s,tagRank=%s" % (isWin, tagPlayerID, tagRank), playerID)
    canAtkRet = __checkAtkQunyingPlayer(curPlayer, tagPlayerID, tagRank)
    if not canAtkRet:
        return
    
    billboardMgr = DBDataMgr.GetBillboardMgr()
    billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
    idRankDict = billBoard.GetIDOrderDict()
    curRank = idRankDict.get(playerID, 0)
    
    updRank = 0
    awardItemList = []
    if isWin:
        # ʤÀûʱ¹Ì¶¨½±Àø
        awardItemList = IpyGameDataPY.GetFuncEvalCfg("QunyingChallenge", 3)
        cmpValue = tagRank
        if PlayerBillboard.UpdateBillboardLayer(playerID, ShareDefine.Def_BT_Qunying, cmpValue):
            updRank = tagRank
        else:
            GameWorld.DebugLog("    ¸üаñµ¥Ê§°Ü", playerID)
            
    awardDict.update({FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(awardItemList), "tagPlayerID":tagPlayerID, "updRank":updRank, "curRank":curRank})
    
    GameWorld.DebugLog("    tagPlayerID=%s,isWin=%s,awardItemList=%s" % (tagPlayerID, isWin, awardItemList), playerID)
    if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, 1):
        return
    
    if isWin:
        ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["Qunying", False, {}], isNotifyAward=False)
        
        rankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
        if not rankHighest or (1 <= tagRank < rankHighest):
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRankHighest, tagRank)
            GameWorld.DebugLog("    ¸üÐÂÀúÊ·×î¸ßÅÅÃû! tagRank=%s" % tagRank, playerID)
            Sync_QunyingInfo(curPlayer) # ¸üÐÂ×î¸ßÅÅÃû
            
    __updQunyingBatRecord(curPlayer, tagPlayerID, isWin, curRank, tagRank)
    
    # Õ½¶·½áÊøϵͳǿÖÆË¢ÐÂÆ¥Åä
    DoQunyingMatchRefresh(curPlayer, True, isSys=True)
    return

def __updQunyingBatRecord(curPlayer, tagPlayerID, isWin, curRank, tagRank):
    ## ¸üÐÂÕ½¶·Ïà¹ØÈÕÖ¾¡¢°ñµ¥µÈ
    
    playerID = curPlayer.GetPlayerID()
    maxCount = 20
    
    tagViewCache = PlayerViewCache.FindViewCache(tagPlayerID)
    
    gameRecMgr = DBDataMgr.GetGameRecMgr()
    atkRecMgr = gameRecMgr.GetRecTypeIDMgr(ShareDefine.Def_GameRecType_QunyingRecord, playerID)
    recData = atkRecMgr.AddRecData(maxCount)
    SetRecAtkType(recData, RecAtkType_Atk)
    SetRecTagPlayerID(recData, tagPlayerID)
    SetRecIsWin(recData, isWin)
    SetRecFace(recData, tagViewCache.GetFace() if tagViewCache else 0)
    SetRecFacePic(recData, tagViewCache.GetFacePic() if tagViewCache else 0)
    SetRecRealmLV(recData, tagViewCache.GetRealmLV() if tagViewCache else 1)
    SetRecLV(recData, tagViewCache.GetLV() if tagViewCache else 1)
    # Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î
    tagPlayerName = tagViewCache.GetPlayerName() if tagViewCache else ""
    recData.SetUserData({"Name":tagPlayerName, "CurRank":curRank, "TagRank":tagRank})
    
    # ±»»÷·½
    if tagPlayerID < ShareDefine.RealPlayerIDStart:
        #GameWorld.DebugLog("Ä¿±ê·ÇÕæʵÍæ¼Ò²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
        return
    
    # ÓÉÓÚ·Ç°ñµ¥ÉϵÄÍæ¼Ò²»»á±»Æ¥Åäµ½£¬ËùÒÔ±»Æ¥Åäµ½µÄ¿ÉÒÔÀí½âΪһ¶¨ÓÐÕ½¶·¼Ç¼£¬ÒòΪҪÉÏ°ñ±ØÐëÕ½¶·¹ý
    defRecMgr = gameRecMgr.GetRecTypeIDMgr(ShareDefine.Def_GameRecType_QunyingRecord, tagPlayerID)
    if not defRecMgr.GetCount():
        GameWorld.DebugLog("Ä¿±êûÓжÔÕ½¼Ç¼²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
        return
    
    finalRecData = defRecMgr.At(defRecMgr.GetCount() - 1)
    if not GameWorld.CheckTimeIsSameWeek(finalRecData.GetTime()):
        GameWorld.DebugLog("Ä¿±ê±¾ÖÜûÓжÔÕ½¼Ç¼²»´¦Àí! tagPlayerID=%s" % tagPlayerID, playerID)
        return
    
    recData = defRecMgr.AddRecData(maxCount)
    SetRecAtkType(recData, RecAtkType_Def)
    SetRecTagPlayerID(recData, playerID)
    SetRecIsWin(recData, not isWin)
    SetRecFace(recData, curPlayer.GetFace())
    SetRecFacePic(recData, curPlayer.GetFacePic())
    SetRecRealmLV(recData, curPlayer.GetOfficialRank())
    SetRecLV(recData, curPlayer.GetLV())
    # Ãû×Ö¡¢×Ô¼ºÃû´Î¡¢¶Ô·½Ãû´Î
    recData.SetUserData({"Name":curPlayer.GetPlayerName(), "CurRank":tagRank, "TagRank":curRank})
    return

def GetQunyingRankHighestAward(curPlayer):
    rankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
    awardRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankSuccAward)
    if not rankHighest:
        return
    GameWorld.DebugLog("ÁìȡȺӢ°ñÀúÊ·×î¸ßÅÅÃû³É¾Í½±Àø! rankHighest=%s,awardRecord=%s" % (rankHighest, awardRecord))
    # Ê״δﵽxÃû³É¾Í½±Àø {"Ãû´Î":[[ÎïÆ·ID, ¸öÊý], ...], ...}
    rankAwardDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 3, {})
    # Ê״δﵽxÃû³É¾Í½±Àø¼Ç¼Ë÷Òý {"Ãû´Î":¼Ç¼Ë÷Òý, ...}£¬¼Ç¼Ë÷Òý´Ó0¿ªÊ¼µÝÔö£¬ÉÏÏߺó²»ÄÜÐÞ¸Ä
    rankIndexDict = IpyGameDataPY.GetFuncEvalCfg("QunyingAward", 4, {})
    awardItemDict = {}
    for rankStr, itemList in rankAwardDict.items():
        rank = int(rankStr)
        if rankHighest > rank:
            GameWorld.DebugLog("    δ´ïµ½: rank=%s" % rank)
            continue
        if rankStr not in rankIndexDict:
            continue
        index = rankIndexDict[rankStr]
        if awardRecord&pow(2, index):
            GameWorld.DebugLog("    ÒÑÁìÈ¡: rank=%s" % rank)
            continue
        awardRecord |= pow(2, index)
        for itemInfo in itemList:
            itemID, itemCount = itemInfo[:2]
            awardItemDict[itemID] = awardItemDict.get(itemID, 0) + itemCount
        GameWorld.DebugLog("    ¿ÉÁìÈ¡: rank=%s,%s,%s" % (rank, itemList, awardItemDict))
    awardItemList = [[itemID, itemCount] for itemID, itemCount in awardItemDict.items()]
    
    GameWorld.DebugLog("    awardRecord=%s,awardRecord=%s" % (awardRecord, awardItemList))
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRankSuccAward, awardRecord)
    ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["QunyingRankHighest", False, {}])
    Sync_QunyingInfo(curPlayer) # Áì½±
    return

def OnProcess(curPlayer):
    CheckQunyingTicketRecover(curPlayer)
    return

def CheckQunyingTicketRecover(curPlayer):
    ## ¼ì²éÌôÕ½Áî»Ö¸´
    storeMax = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 1)
    curTicket = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket)
    lastRecoverTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRecoverTime)
    if curTicket >= storeMax:
        if lastRecoverTime:
            GameWorld.DebugLog("ȺӢÌôÕ½ÁîÒÑÂú!")
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, 0)
            Sync_QunyingInfo(curPlayer) # ÌôÕ½Áî»Ö¸´Âú
        return
    
    curTime = int(time.time())
    passSeconds = curTime - lastRecoverTime
    if not lastRecoverTime or passSeconds < 0:
        GameWorld.DebugLog("ÖØÉèȺӢÌôÕ½Áî»Ö¸´Ê±¼ä!")
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, curTime)
        Sync_QunyingInfo(curPlayer)
        return
    
    cdSeconds = IpyGameDataPY.GetFuncCfg("QunyingChallenge", 2) * 60
    if passSeconds < cdSeconds:
        #GameWorld.DebugLog("ȺӢÌôÕ½Áî»Ö¸´CDÖÐ: passSeconds=%s < %s, lastRecoverTime=%s" % (passSeconds, cdSeconds, GameWorld.ChangeTimeNumToStr(lastRecoverTime)))
        return
    recoverCnt = passSeconds / cdSeconds
    recoverCnt = min(recoverCnt, storeMax - curTicket)
    updRecoverTime = curTime - passSeconds % cdSeconds
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, updRecoverTime)
    GameWorld.DebugLog("»Ö¸´ÈºÓ¢ÌôÕ½Áî: %s,passSeconds=%s,Éϴλָ´:%s" % (recoverCnt, passSeconds, GameWorld.ChangeTimeNumToStr(lastRecoverTime)))
    PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket, recoverCnt)
    if PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_QunyingTicket) >= storeMax:
        GameWorld.DebugLog("ÒÑÂú!")
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRecoverTime, 0)
    Sync_QunyingInfo(curPlayer)
    return

#// B2 10 ȺӢ°ñÆ¥ÅäÍæ¼Ò #tagCSQunyingMatch
#
#struct    tagCSQunyingMatch
#{
#    tagHead         Head;
#    BYTE        IsRefresh;    // 0-´ò¿ª½çÃæʱ²éѯ£¬1-Ç¿ÖÆË¢ÐÂÆ¥ÅäÁбí
#};
def OnQunyingMatch(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    isRefresh = clientData.IsRefresh
    DoQunyingMatchRefresh(curPlayer, isRefresh)
    return

def DoQunyingMatchRefresh(curPlayer, isRefresh, isSys=False):
    ## Íæ¼ÒË¢ÐÂÆ¥Åä¶ÔÊÖ
    playerID = curPlayer.GetPlayerID()
    GameWorld.DebugLog("ȺӢ°ñÍæ¼ÒË¢ÐÂÆ¥ÅäÁбí: isRefresh=%s,isSys=%s" % (isRefresh, isSys), playerID)
    
    billboardMgr = DBDataMgr.GetBillboardMgr()
    billBoard = billboardMgr.GetBillboard(ShareDefine.Def_BT_Qunying)
    if not billBoard:
        return
    layerIDList = billBoard.GetLayerIDList()
    idRankDict = billBoard.GetIDOrderDict()
    layerIDCnt = len(layerIDList)
    playerRank = idRankDict.get(playerID, layerIDCnt + 1) # δÉÏ°ñĬÈÏ×î´óÃû´Î + 1
    
    # Æ¥Åä¶ÔÏ󻺴æ
    if playerID not in PyGameData.g_qunyingPlayerMatchDict:
        PyGameData.g_qunyingPlayerMatchDict[playerID] = []
    matchRankList = PyGameData.g_qunyingPlayerMatchDict[playerID]
    if not isRefresh and matchRankList:
        # ·ÇˢеIJ¢ÇÒÒѾ­ÓмǼµÄÖ±½Óͬ²½
        GameWorld.DebugLog("    ·ÇË¢ÐÂÇÒÓÐÊý¾Ý£¬Ö±½Óͬ²½! matchRankList=%s" % matchRankList, playerID)
        __SyncQunyingMatchList(curPlayer, matchRankList, layerIDList)
        return
    
    # Æ¥Åä¿ÉÌôսĿ±ê¹æÔò {Íæ¼ÒÃû´Î:[[Ãû´Î²îÖµ, Æ¥Åäx¸ö], ...], ...} Ãû´Î²îÖµÖ§³ÖÕý¸º
    matchRuleDict = IpyGameDataPY.GetFuncEvalCfg("QunyingMatch", 1, {})
    rankList = matchRuleDict.keys()
    rankList.sort()
    matchRuleList = []
    for rank in rankList:
        if playerRank <= rank:
            matchRuleList = matchRuleDict[rank]
            break
    if not matchRuleList:
        matchRuleList = matchRuleDict[rankList[-1]] # ûÓÐĬÈÏÈ¡×îºóÒ»µµ
        
    matchRuleList.sort()
    GameWorld.DebugLog("    layerIDCnt=%s,playerRank=%s,matchRuleList=%s" % (layerIDCnt, playerRank, matchRuleList), playerID)
    if not matchRuleList:
        return
    
    if isRefresh and not isSys:
        refreshMax = IpyGameDataPY.GetFuncCfg("QunyingMatch", 3)
        if refreshMax:
            refreshCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRefreshCnt)
            if refreshCnt >= refreshMax:
                GameWorld.DebugLog("    ÒÑ´ï×î´óˢдÎÊý! refreshCnt=%s >= %s" % (refreshCnt, refreshMax), playerID)
                return
        costMoney, moneyValue = IpyGameDataPY.GetFuncEvalCfg("QunyingMatch", 2)
        if not costMoney or not moneyValue or not PlayerControl.PayMoney(curPlayer, costMoney, moneyValue, "Qunying"):
            return
        if refreshMax:
            refreshCnt += 1
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_QunyingRefreshCnt, refreshCnt)
            Sync_QunyingInfo(curPlayer) # Ë¢ÐÂÆ¥Åä
            
    matchRankList = [] # ÒòΪÓÐÌî³ä»úÆ÷ÈË£¬»úÆ÷ÈËID¿ÉÄÜÖظ´£¬¹Ì°´Ãû´ÎλÖÃÆ¥Åä [rank, ...]
    if 1 <= playerRank <= layerIDCnt:
        matchRankList.append(playerRank) # Íæ¼ÒÓÐÉÏ°ñʱĬÈÏÒª°üº¬Íæ¼Ò×Ô¼º
    # [[Ãû´Î²îÖµ, Æ¥Åäx¸ö], ...]
    # µÚÒ»ÃûʱƥÅäʾÀý: [[50, 4]]
    # δÉÏ°ñʱƥÅäʾÀý£º[[-500, 5]]
    # °ñµ¥ÖÐʱƥÅäʾÀý£º[[-300, 1], [-200, 1], [-100, 1],[100, 1]]
    for mIndex, matchRule in enumerate(matchRuleList):
        rankDiff, matchCnt = matchRule
        nextDiff = None
        if mIndex < len(matchRuleList) - 1:
            nextDiff = matchRuleList[mIndex + 1][0]
            
        if mIndex == 0:
            if rankDiff >= 0: # µÚ1¸ö¾Í¿ªÊ¼Æ¥ÅäºóÃæµÄ£¬Ö±½Ó´ÓÍæ¼ÒºóÒ»Ãû¿ªÊ¼£¬·ñÔòÖ±½Ó´ÓÓëÍæ¼ÒÃû´ÎµÄ²îÖµ¿ªÊ¼
                fromRank = playerRank + 1
            else:
                fromRank = playerRank + rankDiff
                
        # ·Ç×îºóÒ»µµµÄÇé¿ö
        if nextDiff != None:
            if rankDiff < 0 and nextDiff >= 0:
                toRank = playerRank - 1 # ²îÖµÕý¸º±ä¸ü£¬Ä¬ÈÏÒÔÍæ¼ÒÃû´Î·Öµµ
            else:
                toRank = fromRank + (nextDiff - rankDiff) - 1 # ~ ÓëÏÂÒ»µµµÄ²îÖµ
                
        # ×îºóÒ»µµ
        else:
            if rankDiff < 0:
                toRank = layerIDCnt
            else:
                toRank = fromRank + rankDiff - 1
                
        fromRank = max(fromRank, 1)
        toRank = min(toRank, layerIDCnt)
        if fromRank > toRank:
            GameWorld.ErrLog("Æ¥Åä¹æÔòÒì³£! mIndex=%s,fromRank=%s,toRank=%s,%s" % (mIndex, fromRank, toRank, matchRuleList))
            break
        
        randRankList = range(fromRank, toRank + 1)
        random.shuffle(randRankList)
        rankCnt = len(randRankList)
        mCnt = 0
        # ²»ÓÃÑé֤Ŀ±êID£¬ÔÊÐíÆ¥ÅäÖظ´µÄID£¬Ö»ÒªÆ¥ÅäµÄÄ¿±êÃû´Î²»Öظ´¼´¿É
        for randRank in randRankList:
            if randRank in matchRankList:
                continue
            tagID = layerIDList[randRank - 1]
            GameWorld.DebugLog("    Æ¥ÅäÃû´Î: %s ~ %s,%sÃû,randRank=%s,tagID=%s" % (fromRank, toRank, rankCnt, randRank, tagID), playerID)
            matchRankList.append(randRank)
            mCnt += 1
            if mCnt >= matchCnt:
                break
            
        if toRank == playerRank - 1:
            fromRank = toRank + 2
        else:
            fromRank = toRank + 1
            
        if fromRank > layerIDCnt:
            break
        
    matchRankList.sort()
    GameWorld.DebugLog("    Æ¥ÅäÃû´Î½á¹û: matchRankList=%s" % (matchRankList), playerID)
    PyGameData.g_qunyingPlayerMatchDict[playerID] = matchRankList
    __SyncQunyingMatchList(curPlayer, matchRankList, layerIDList)
    return

def __SyncQunyingMatchList(curPlayer, matchRankList, layerIDList):
    ## ͬ²½Æ¥ÅäÁбí
    layerIDCnt = len(layerIDList)
    clientPack = ChPyNetSendPack.tagSCQunyingMatchList()
    clientPack.MatchList = []
    for rank in matchRankList:
        if rank <= 0 or rank > layerIDCnt:
            continue
        matchID = layerIDList[rank - 1]
        viewCache = PlayerViewCache.FindBattleViewCache(matchID)
        if not viewCache:
            continue
        matchInfo = ChPyNetSendPack.tagSCQunyingMatchInfo()
        matchInfo.Rank = rank
        matchInfo.PlayerID = matchID
        if viewCache:
            fightPower = TurnAttack.GetCacheLineupFightPower(viewCache, ShareDefine.BatPreset_QunyingDef)
            matchInfo.PlayerName = viewCache.GetPlayerName()
            matchInfo.RealmLV = viewCache.GetRealmLV()
            matchInfo.LV = viewCache.GetLV()
            matchInfo.Face = viewCache.GetFace()
            matchInfo.FacePic = viewCache.GetFacePic()
            matchInfo.FightPower = fightPower % ChConfig.Def_PerPointValue
            matchInfo.FightPowerEx = fightPower / ChConfig.Def_PerPointValue
            matchInfo.TitleID = viewCache.GetTitleID()
            matchInfo.ModelMark = viewCache.GetModelMark()
            matchInfo.EquipShowSwitch = viewCache.GetEquipShowSwitch()
            matchInfo.ServerID = viewCache.GetServerID()
        else:
            matchInfo.PlayerName = "p%s" % matchID
        clientPack.MatchList.append(matchInfo)
    clientPack.MatchCount = len(clientPack.MatchList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_QunyingInfo(curPlayer):
    clientPack = ChPyNetSendPack.tagSCQunyingPlayerInfo()
    clientPack.RefreshCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRefreshCnt)
    clientPack.LastRecoverTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRecoverTime)
    clientPack.RankHighest = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankHighest)
    clientPack.RankSuccAward = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_QunyingRankSuccAward)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return