#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GameWorldLogic.FBProcess.GameLogic_ElderBattlefield
#
# @todo:ÉϹÅÕ½³¡
# @author xdh
# @date 2016-08-29
# @version 1.0
#
#
# ÏêϸÃèÊö: ÉϹÅÕ½³¡
#
#-------------------------------------------------------------------------------
#"""Version = 2017-07-12 21:00""
#-------------------------------------------------------------------------------

import ChConfig
import FBCommon
import GameWorld
import PlayerControl
import IpyGameDataPY
import GameWorldProcess
import ItemCommon
import ItemControler
import IPY_GameWorld
import ShareDefine
import PlayerSuccess
import GameMap
import BuffSkill
import FormulaControl
import PyGameData
import NPCCustomRefresh
import SkillShell
import EventReport
import SkillCommon
import PlayerWeekParty

import random
import time

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

# ¸±±¾Íæ¼Ò×Öµäkey
FBPlayerDict_Score = 'FBPD_Score%s'  # Íæ¼Òµ±Ç°»ý·Ö
FBPlayerDict_KillCnt = 'FBPD_KillCnt'  # Íæ¼Òµ±Ç°É±µÐÊý
FBPD_LastCheckTick = 'FBPD_LastCheckTick'  # ¼ì²éË¢buffʱ¼ä
FBPD_LastCheckTick1 = 'FBPD_LastCheckTick1'  # ¼ì²éË¢»úÆ÷ÈËʱ¼ä
FBPlayerDict_ContKillCntEx = 'FBPD_ContKillCntEx'  # Íæ¼Òµ±Ç°×ÜÁ¬É±Êý
FBPlayerDict_TotalExp = 'FBPlayerDict_TotalExp%s'  # »ñµÃµÄ×ܾ­Ñé
FBPlayerDict_TotalExpPoint = 'FBPlayerDict_TotalExpPoint%s'  # »ñµÃµÄ×ܾ­Ñéµã
FBPlayerDict_EnemyID = 'FBPD_EnemyID'  # Íæ¼Ò×î½üÒ»¸ö³ðµÐID
FBPlayerDict_RebornBuffLV = 'RebornBuffLV'  # Íæ¼Òµ±Ç°¸´»îBUFFLV
Map_ElderBattlefield_StartTick = "Map_ElderBattlefield_StartTick"  # ¸±±¾¿ªÊ¼Ê±¼ä
Map_ElderBattlefield_TopPlayer = "Map_ElderBattlefield_TopPlayer"  # »ý·ÖÍõ

#
(
Def_PlayerCnt,  # ÕæÈËÊýÁ¿
Def_RobotCnt,  # »úÆ÷ÈË×î´óÊýÁ¿
Def_TotalCnt,  # ÕæÈË+»úÆ÷ÈË×ܺÍ
) = range(3)

#µ±Ç°¸±±¾µØͼµÄ״̬
(
FB_Step_Open,  # ¸±±¾¿ªÆô
FB_Step_Fighting,  # ¸±±¾½øÐÐÖÐ
FB_Step_Over,  # ¸±±¾½áÊø
) = range(3)

def OnFBPlayerOnLogin(curPlayer):
    mapID = GameWorld.GetMap().GetMapID()
    if mapID != ChConfig.Def_FBMapID_ElderBattlefield:
        OnElderBattlefieldFBResult(curPlayer, True)
    return

def OnElderBattlefieldStateChange(state, tick):
    #»î¶¯×´Ì¬±ä¸ü
#    mapID = GameWorld.GetMap().GetMapID()
#    if mapID != ChConfig.Def_FBMapID_ElderBattlefield:
#        return
    GameWorld.DebugLog('    ÉϹÅÕ½³¡»î¶¯×´Ì¬±ä¸ü state=%s' % state)

    if state == 1:
        GameWorld.GetGameWorld().SetGameWorldDict(Map_ElderBattlefield_StartTick, tick)
        GameWorld.GetGameWorld().SetGameWorldDict(Map_ElderBattlefield_TopPlayer, 0)

    else:
        GiveJoinPrize()

    return


##¿ªÆô¸±±¾
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ¿ªÆô¸±±¾
def OnOpenFB(tick):
    mapID = GameWorld.GetMap().GetMapID()
    lineID = GameWorld.GetGameWorld().GetPropertyID() - 1
    refreshIDList = FBCommon.GetFBLineRefreshNPC(mapID, lineID)
    #GameWorld.Log('    lineID=%s,refreshIDList=%s'%(lineID, refreshIDList))
    if refreshIDList:
        for refreshID in refreshIDList:
            NPCCustomRefresh.SetNPCRefreshByID(refreshID)
    return


##¹Ø±Õ¸±±¾
# @param tick ʱ¼ä´Á
# @return ÎÞÒâÒå
# @remarks 
def OnCloseFB(tick):
    GameWorld.GetGameWorld().SetPropertyID(0)
    return


## ÊÇ·ñÄܹ»Í¨¹ý»î¶¯²éѯ½øÈë
#  @param curPlayer Íæ¼ÒʵÀý
#  @param mapID µØͼID
#  @param lineID Ïß·id
#  @param tick ʱ¼ä´Á
#  @return ²¼¶ûÖµ
def OnEnterFBEvent(curPlayer, mapID, lineID, tick):
    GameWorld.DebugLog("OnEnterFBEvent map %s - %s" % (mapID, lineID))

    return True


##ÊÇ·ñ¿ÉÒÔ½øÈë
# @param ask ÇëÇó½á¹¹Ìå
# @param tick ʱ¼ä´Á
# @return
def OnChangeMapAsk(ask, tick):
    GameWorld.DebugLog("OnChangeMapAsk  CopyMapID=%s" % (ask.GetCopyMapID()))
    
    #¿É½øÈë
    return IPY_GameWorld.cmeAccept


##Íæ¼Ò½øÈ븱±¾
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ÎÞÒâÒå
# @remarks Íæ¼Ò½øÈ븱±¾
def DoEnterFB(curPlayer, tick):
    playerID = curPlayer.GetPlayerID()
    GameWorld.DebugLog("DoEnterFB...", playerID)
    
    gameFB = GameWorld.GetGameFB()
    fbStep = gameFB.GetFBStep()
    startTick = GameWorld.GetGameWorld().GetGameWorldDictByKey(Map_ElderBattlefield_StartTick)
    
    closeFB_RemainTick = max(0, FBCommon.GetFBLineStepTime(ChConfig.Def_FBMapID_ElderBattlefield) * 1000 - (tick - startTick))
    if not closeFB_RemainTick:
        PlayerControl.PlayerLeaveFB(curPlayer)
        return
    curPlayer.Sync_TimeTick(IPY_GameWorld.tttTowerTake, 0, closeFB_RemainTick, True) 
    
    if not FBCommon.GetHadSetFBPropertyMark():
        lineID = GameWorld.GetGameWorld().GetPropertyID() - 1
        FBCommon.SetFBPropertyMark(lineID)
        
    if not FBCommon.GetHadDelTicket(curPlayer):
        FBCommon.SetHadDelTicket(curPlayer)
        if FBCommon.AddEnterFBCount(curPlayer, ChConfig.Def_FBMapID_ElderBattlefield):
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ElderBattlefieldStage, 0)
            GameWorld.GetGameWorld().SetGameWorldDict(FBPlayerDict_Score % playerID, 0)
            GameWorld.GetGameWorld().SetGameWorldDict(FBPlayerDict_TotalExp % playerID, 0)
            GameWorld.GetGameWorld().SetGameWorldDict(FBPlayerDict_TotalExpPoint % playerID, 0)
            EventReport.WriteEvent_FB(curPlayer, ChConfig.Def_FBMapID_ElderBattlefield, 0, ChConfig.CME_Log_Start)
            PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_ElderBattlefield, 1)
    else:
        rebornBuffLV = GameWorld.GetGameFB().GetPlayerGameFBDictByKey(playerID, FBPlayerDict_RebornBuffLV)
        __DoAddRebornBuff(curPlayer, rebornBuffLV, tick)
    DoFBHelp(curPlayer, tick)
    return


##¸±±¾Íæ¼Ò½øÈëµã, Íæ¼Ò·ÖÉ¢Ôڰ뾶3¸ñ·¶Î§
# @param curPlayer Íæ¼ÒʵÀý
# @param mapID µØͼID
# @param lineId ·ÖÏßID
# @param tick ʱ¼ä´Á
# @return ×ø±êÁбí(X,Y)
# @remarks ¸±±¾Íæ¼Ò½øÈëµã
def OnGetFBEnterPos(curPlayer, mapID, lineId, ipyEnterPosInfo, tick):
    return random.choice(ipyEnterPosInfo)


## »ñÈ¡²ãËæ»ú×ø±êµã
def __GetRandPos():
    ipyEnterPosInfo = FBCommon.GetFBLineEnterPosInfo(ChConfig.Def_FBMapID_ElderBattlefield, 0)
    enterPos = random.choice(ipyEnterPosInfo)
    dist = 3 if len(enterPos) <= 2 else enterPos[2]
    posPoint = GameMap.GetEmptyPlaceInArea(enterPos[0], enterPos[1], dist)
    return posPoint.GetPosX(), posPoint.GetPosY()


##Íæ¼ÒÍ˳ö¸±±¾
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ÎÞÒâÒå
def DoExitFB(curPlayer, tick):
    buffIDList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldBuff')
    for buffID in buffIDList:
        BuffSkill.DelBuffBySkillID(curPlayer, buffID, tick)
    
    skillBuffID = IpyGameDataPY.GetFuncCfg('ElderBattlefieldRobot', 3)
    BuffSkill.DelBuffBySkillID(curPlayer, skillBuffID, tick)
    FBCommon.UpdFBLineNPCStrengthenLV(curPlayer.GetPlayerID(), True)
    return


##Íæ¼ÒÖ÷¶¯À뿪¸±±¾.
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
def DoPlayerLeaveFB(curPlayer, tick):

    return


##Íæ¼ÒÇл»µØͼ
def DoPlayerChangeMapLogic(curPlayer):
    #¸±±¾µÄÁ¬É±£¬³ðµÐ£¬ËÀÍöBUFFÖØÖ㬻ý·Ö²»ÖØÖÃ
    
    playerID = curPlayer.GetID()
    gameFB = GameWorld.GetGameFB()
    gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_ContKillCntEx, 0)
    gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_EnemyID, 0)
    gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_RebornBuffLV, 0)
    return


##¸±±¾×ÜÂß¼­¼ÆʱÆ÷
# @param tick ʱ¼ä´Á
# @return ÎÞÒâÒå
# @remarks ¸±±¾×ÜÂß¼­¼ÆʱÆ÷
def OnProcess(tick):
    fbStep = GameWorld.GetGameFB().GetFBStep()
    #GameWorld.DebugLog("    OnProcess...")
    if fbStep == FB_Step_Open:
        if FBCommon.GetFBFuncOpenState(ChConfig.Def_FBMapID_ElderBattlefield):
            FBCommon.SetFBStep(FB_Step_Fighting, tick)
    elif fbStep == FB_Step_Fighting:
        if not FBCommon.GetFBFuncOpenState(ChConfig.Def_FBMapID_ElderBattlefield):
            #GiveJoinPrize()
            #»ý·ÖÍõ
            topPlayerID = GameWorld.GetGameWorld().GetGameWorldDictByKey(Map_ElderBattlefield_TopPlayer)
            if topPlayerID:
                topAwardList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldTopAward')
                if topAwardList:
                    PlayerControl.SendMailByKey("ElderBattlefieldTopMail", [topPlayerID], topAwardList) 
                    PlayerControl.WorldNotify(0, 'ElderBattlefieldBest', [PyGameData.g_sgzztopPlayerName, topAwardList[0][0]])
                GameWorld.GetGameWorld().SetGameWorldDict(Map_ElderBattlefield_TopPlayer, 0)
            
            
            FBCommon.SetFBStep(FB_Step_Over, tick)
            FBCommon.DoLogic_FBKickAllPlayer()
            GameWorldProcess.CloseFB(tick)
        else:
            __CheckRefreshBuffNPC(tick)
            __RefreshRobot(tick)
    return


def __CheckRefreshBuffNPC(tick):
    #¼ì²ébuffnpcË¢¹Ö
    gameFB = GameWorld.GetGameFB()
    lastCheckTick = gameFB.GetGameFBDictByKey(FBPD_LastCheckTick)

    if lastCheckTick and tick - lastCheckTick < 10000:
        return
    gameFB.SetGameFBDict(FBPD_LastCheckTick, tick)
    
    allRmark = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldBuff', 3)
    maxCnt = IpyGameDataPY.GetFuncCfg('ElderBattlefieldBuff', 4)

    rmarkList = []  #¿ÉË¢¹ÖµÄ±êʶµã
    npcCnt = 0
    gameNPC = GameWorld.GetNPCManager()
    for i in xrange(gameNPC.GetCustomNPCRefreshCount()):
        npcRefresh = gameNPC.GetCustomNPCRefreshAt(i)
        rmark = npcRefresh.GetRefreshMark()
        if rmark not in allRmark:
            continue
        npcCnt += npcRefresh.GetCount()
        if not npcRefresh.GetCount():
            rmarkList.append(rmark)
    
    needAddCnt = maxCnt - npcCnt
    if not needAddCnt:
        return
    random.shuffle(rmarkList)
    npcID = IpyGameDataPY.GetFuncCfg('ElderBattlefieldBuff', 2)
    for rMark in rmarkList[:needAddCnt]:
        NPCCustomRefresh.SetNPCRefresh(rMark, [(npcID, 1)], 1, 1)
    NPCCustomRefresh.ProcessAllNPCRefresh(tick)  # Á¢¼´³ö·¢Ò»´Î±êʶµãË¢ÐÂ
    
    return


def __RefreshRobot(tick):
    ##ˢлúÆ÷ÈË
    gameFB = GameWorld.GetGameFB()
    lastCheckTick = gameFB.GetGameFBDictByKey(FBPD_LastCheckTick1)
    if lastCheckTick and tick - lastCheckTick < 2000:
        return
    gameFB.SetGameFBDict(FBPD_LastCheckTick1, tick)
    fblineid = GameWorld.GetGameWorld().GetLineID()
    g_elderBattleRobotDieList = PyGameData.g_elderBattleRobotDieDict.get(fblineid, [])
    robotCfgDict = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldCfg', 3, {})
    lineID = GameWorld.GetGameWorld().GetPropertyID() - 1
    if lineID not in robotCfgDict:
        return
    robotMaxLV = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenMaxLV)
    if GameWorld.GetMapCopyPlayerManager().GetPlayerCount() <= 0 or not robotMaxLV:
        #GameWorld.DebugLog("ûÍæ¼Ò£¬²»Ë¢»úÆ÷ÈË! ")
        return
    rmarkList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldRobot', 5)
    curNPCCnt = 0
    robotCntDict = {}
    gameNPC = GameWorld.GetNPCManager()
    for i in xrange(gameNPC.GetCustomNPCRefreshCount()):
        npcRefresh = gameNPC.GetCustomNPCRefreshAt(i)
        rmark = npcRefresh.GetRefreshMark()
        if rmark not in rmarkList:
            continue
        cnt = npcRefresh.GetCount()
        robotCntDict[rmark] = cnt
        curNPCCnt += cnt
    
    robotCfg = robotCfgDict[lineID]
    curPlayerCnt = GameWorld.GetMapCopyPlayerManager().GetPlayerCount()
    maxRobotCnt = min(robotCfg[Def_TotalCnt] - curPlayerCnt, robotCfg[Def_RobotCnt])
    extraCnt = maxRobotCnt - curNPCCnt - len(g_elderBattleRobotDieList)
    rebornTime = IpyGameDataPY.GetFuncCfg('ElderBattlefieldRobot')
    rebornCnt = 0
    for dieTick in g_elderBattleRobotDieList:
        if tick - dieTick < rebornTime * 1000:
            break
        rebornCnt += 1
    PyGameData.g_elderBattleRobotDieDict[fblineid] = g_elderBattleRobotDieList[rebornCnt:]
    refreshCnt = rebornCnt + extraCnt
    #GameWorld.DebugLog('    ˢлúÆ÷ÈË rebornCnt=%s,extraCnt=%s,refreshCnt=%s,robotCntDict=%s'%(rebornCnt, extraCnt,refreshCnt,robotCntDict))
    if refreshCnt > 0:
        npcID = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldRobot', 2, {}).get(lineID, 0)
        if not npcID:
            return
        
        random.shuffle(rmarkList)
        hasRefreshCnt = 0
        for i, rMark in enumerate(rmarkList):
            if hasRefreshCnt >=refreshCnt:
                break
            curCnt = robotCntDict.get(rMark, 0)
            cnt = 1 if i < len(rmarkList)-1 else refreshCnt-hasRefreshCnt
            hasRefreshCnt += cnt
            curMaxCnt = curCnt+cnt
            NPCCustomRefresh.SetNPCRefresh(rMark, [(npcID, cnt)], curMaxCnt, cnt)
        NPCCustomRefresh.ProcessAllNPCRefresh(tick)
        
    return


##Õ½¶·Âß¼­
# @param tick  ʱÖÓ
# @return ÎÞÒâÒå
# @remarks Õ½¶·Âß¼­
def GiveJoinPrize():
    playerManager = GameWorld.GetPlayerManager()
    for i in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(i)
        if curPlayer == None or not curPlayer.GetInitOK():
            continue
        OnElderBattlefieldFBResult(curPlayer)
        
    
    return


def OnElderBattlefieldFBResult(curPlayer, isLogin=False):
    # Íæ¼Ò´¦ÀíÉϹÅÕ½³¡½áËãÐÅÏ¢
    curStage = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ElderBattlefieldStage, 0)
    if not curStage:
        return
    GameWorld.DebugLog('    Íæ¼Ò´¦ÀíÉϹÅÕ½³¡½áËãÐÅÏ¢ , isLogin=%s' % isLogin, curPlayer.GetPlayerID())
    lineID = 0  #GameWorld.GetGameWorld().GetPropertyID() -1
    fbRewardDict = FBCommon.GetFBLineReward(ChConfig.Def_FBMapID_ElderBattlefield, lineID)
    
    
    itemList = fbRewardDict.get(curStage, [])
    succIDList = PlayerSuccess.GetCanGetAwardSuccByType(curPlayer, [ShareDefine.SuccType_ElderBattlefieldKill, ShareDefine.SuccType_ElderBattlefieldConKill])
    succAwardDict = PlayerSuccess.GiveSuccAward(curPlayer, succIDList, False)
    if not itemList and not succAwardDict:
        return
    rewardItemList = []
    for itemID, itemCnt in itemList:
        rewardItemList.append([itemID, itemCnt, 1])
    for itemID, itemCnt in succAwardDict.items():
        rewardItemList.append([itemID, itemCnt, 1])
    needSpace = len(rewardItemList)
    emptySpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem, needSpace)
    mapID = GameWorld.GetMap().GetMapID()
    if mapID != ChConfig.Def_FBMapID_ElderBattlefield or isLogin or emptySpace < needSpace:
        PlayerControl.SendMailByKey("ElderBattlefieldMail" if mapID == ChConfig.Def_FBMapID_ElderBattlefield else 'ElderBattlefieldMail2', [curPlayer.GetPlayerID()], rewardItemList)
    else:
        for itemID, itemCnt, isBind in rewardItemList:
            ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, isBind, [IPY_GameWorld.rptItem], event=["ElderBattlefield", False, {}])
    
        overDict = {FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(itemList), FBCommon.Over_succItemInfo:FBCommon.GetJsonItemList(succAwardDict.items())}
        FBCommon.NotifyFBOver(curPlayer, ChConfig.Def_FBMapID_ElderBattlefield, lineID, 1, overDict)
    #½áËã¹ý£¬ÖØÖý׶Î
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ElderBattlefieldStage, 0)
    return


def __AddElderBattlefieldPlayerScore(curPlayer, gameFB, addValue):
    playerID = curPlayer.GetPlayerID()
    gameWorld = GameWorld.GetGameWorld()
    updScore = gameWorld.GetGameWorldDictByKey(FBPlayerDict_Score % playerID) + addValue
    gameWorld.SetGameWorldDict(FBPlayerDict_Score % playerID, updScore)
    #¸üлý·ÖÍõ
    
    topPlayerID = gameWorld.GetGameWorldDictByKey(Map_ElderBattlefield_TopPlayer)
    if not topPlayerID or updScore > gameWorld.GetGameWorldDictByKey(FBPlayerDict_Score % topPlayerID):
        gameWorld.SetGameWorldDict(Map_ElderBattlefield_TopPlayer, playerID)

        topName = curPlayer.GetName()
        PyGameData.g_sgzztopPlayerName = topName
        PlayerControl.WorldNotify(0, 'AncientBattlefield_9', [topName])
        
    if gameWorld.GetGameWorldDictByKey(Map_ElderBattlefield_TopPlayer) == playerID:
        playerManager = GameWorld.GetPlayerManager()
        for i in range(0, playerManager.GetPlayerCount()):
            player = playerManager.GetPlayerByIndex(i)
            if player == None or not player.GetInitOK():
                continue
            if player.GetPlayerID() == playerID:
                continue
            DoFBHelp(player, 0)
    curStage = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ElderBattlefieldStage, 0)
    stageScoreList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldCfg', 4)
    
    if curStage < len(stageScoreList) and updScore >= stageScoreList[curStage]:
        addTotalExp = 0
        reExp = PlayerControl.GetPlayerReExp(curPlayer)
        expFormulaDict = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldExp')
        for score in stageScoreList[curStage:]:
            if updScore >= score:
                updStage = stageScoreList.index(score) + 1
                addExp = eval(FormulaControl.GetCompileFormula("ElderBattlefieldExp%s" % updStage, expFormulaDict[updStage]))
                addTotalExp += addExp
        GameWorld.DebugLog('curStage=%s,updStage=%s,addTotalExp=%s' % (curStage, updStage, addTotalExp), playerID)
        PlayerControl.PlayerControl(curPlayer).AddExp(addTotalExp)
        exp = gameWorld.GetGameWorldDictByKey(FBPlayerDict_TotalExp % playerID)
        expPoint = gameWorld.GetGameWorldDictByKey(FBPlayerDict_TotalExpPoint % playerID)
        totalExp = expPoint * ChConfig.Def_PerPointValue + exp
        updTotalExp = totalExp + addTotalExp
        updExp = updTotalExp % ChConfig.Def_PerPointValue
        updExpPoint = updTotalExp / ChConfig.Def_PerPointValue
        gameWorld.SetGameWorldDict(FBPlayerDict_TotalExp % playerID, updExp)
        gameWorld.SetGameWorldDict(FBPlayerDict_TotalExpPoint % playerID, updExpPoint)
        
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ElderBattlefieldStage, updStage)
    
    return updScore

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


##»ñµÃ¸±±¾°ïÖúÐÅÏ¢, ÓÃÓÚ֪ͨÕóÓª±È·ÖÌõ
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ÎÞÒâÒå
# @remarks ÓÃÓÚ֪ͨÕóÓª±È·ÖÌõ
def DoFBHelp(curPlayer, tick):
    gameWorld = GameWorld.GetGameWorld()
    lineID = gameWorld.GetLineID()
    playerID = curPlayer.GetPlayerID()
    score = gameWorld.GetGameWorldDictByKey(FBPlayerDict_Score % playerID)
    stageScoreList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldCfg', 4)
    curStage = min(curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ElderBattlefieldStage, 0) + 1, len(stageScoreList))
    #killCnt = gameFB.GetPlayerGameFBDictByKey(playerID, FBPlayerDict_KillCnt)
    exp = gameWorld.GetGameWorldDictByKey(FBPlayerDict_TotalExp % playerID)
    expPoint = gameWorld.GetGameWorldDictByKey(FBPlayerDict_TotalExpPoint % playerID)
    helpDict = {FBCommon.Help_score:score, FBCommon.Help_step:curStage,
                FBCommon.Help_exp:exp, FBCommon.Help_expPoint:expPoint}
    
    topPlayerID = gameWorld.GetGameWorldDictByKey(Map_ElderBattlefield_TopPlayer)

    topScore = gameWorld.GetGameWorldDictByKey(FBPlayerDict_Score % topPlayerID)
    
    helpDict['topName'] = PyGameData.g_sgzztopPlayerName if topPlayerID else ''
    helpDict['topScore'] = topScore if topPlayerID else 0
    helpDict['topPlayerID'] = topPlayerID
    #helpDict[FBCommon.Help_lineID] = GameWorld.GetGameWorld().GetLineID()
    helpDict['enemyID'] = GameWorld.GetGameFB().GetPlayerGameFBDictByKey(playerID, FBPlayerDict_EnemyID)
    helpDict[FBCommon.Help_robotJob] = PyGameData.g_fbRobotJobDict.get(lineID, {})
    GameWorld.DebugLog("DoFBHelp %s" % helpDict, playerID)
    FBCommon.Notify_FBHelp(curPlayer, helpDict)
    return

def DoFBOnNPCKill_Player(curNPC, curPlayer, tick):
    if curNPC.GetNPCID() in IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldRobot', 2, {}).values():
        DoFBOnKill_Player(curNPC, curPlayer, tick)
    return

##´¦Àí¸±±¾ÖÐɱËÀÍæ¼ÒÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @param defender ·ÀÊØÕß
# @param tick ʱ¼ä´Á
# @return ²¼¶ûÖµ
# @remarks ´¦Àí¸±±¾ÖÐɱËÀÍæ¼ÒÂß¼­
def DoFBOnKill_Player(atkobj, defender, tick):
    gameFB = GameWorld.GetGameFB()
    atkIsPlayer = atkobj.GetGameObjType() == IPY_GameWorld.gotPlayer
    baseCnt = IpyGameDataPY.GetFuncCfg('ElderBattlefieldSys', 2)
    addScore = 0
    if atkIsPlayer:
        playerID = atkobj.GetPlayerID()
        GameWorld.DebugLog("DoFBOnKill_Player", playerID)
    
        # »÷ɱ·½´¦Àí
        killCnt = gameFB.GetPlayerGameFBDictByKey(playerID, FBPlayerDict_KillCnt) + 1  # »÷ɱÊý
        gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_KillCnt, killCnt)
        if killCnt == 1:#Ê×ɱÌáʾ
            PlayerControl.NotifyCode(atkobj, 'AncientBattlefield_10', [1])
        
        contKillCntEx = gameFB.GetPlayerGameFBDictByKey(playerID, FBPlayerDict_ContKillCntEx) + 1  # Á¬É±Êý
        gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_ContKillCntEx, contKillCntEx)
        #Á¬É±¹ã²¥
        ckillSysList = IpyGameDataPY.GetFuncCfg('ElderBattlefieldSys', 1)
        
        perCnt = IpyGameDataPY.GetFuncCfg('ElderBattlefieldSys', 3)
        if contKillCntEx >= baseCnt and contKillCntEx % perCnt == 0:
            sysIndex = min((contKillCntEx - baseCnt) / perCnt, len(ckillSysList) - 1)
            PlayerControl.FBNotify(ckillSysList[sysIndex], [atkobj.GetName(), contKillCntEx])
            PlayerControl.NotifyCode(atkobj, 'AncientBattlefield_10', [contKillCntEx])
        if contKillCntEx == 5:
            PlayerControl.NotifyCode(atkobj, 'AncientBattlefield_10', [5])
  
        # »÷ɱ·½³É¾Í
        PlayerSuccess.DoAddSuccessProgress(atkobj, ShareDefine.SuccType_ElderBattlefieldKill, 1)
        PlayerSuccess.DoAddSuccessProgress(atkobj, ShareDefine.SuccType_ElderBattlefieldConKill, 1, [contKillCntEx])
        
        addScore = IpyGameDataPY.GetFuncCfg('ElderBattlefieldCfg', 2)
        
    # ±»É±·½´¦Àí
    tagPlayerID = 0
    if defender.GetGameObjType() == IPY_GameWorld.gotPlayer:
        tagPlayerID = defender.GetPlayerID()
        defContKillCntEx = gameFB.GetPlayerGameFBDictByKey(tagPlayerID, FBPlayerDict_ContKillCntEx)
        if defContKillCntEx >= baseCnt:
            if atkIsPlayer:
                PlayerControl.FBNotify('AncientBattlefield_7', [atkobj.GetName(), defender.GetName(), defContKillCntEx])
            else:
                PlayerControl.FBNotify('AncientBattlefield_robot', [atkobj.GetNPCID(), atkobj.GetID(), defender.GetName(), defContKillCntEx])
        gameFB.SetPlayerGameFBDict(tagPlayerID, FBPlayerDict_ContKillCntEx, 0)
        #¼Ç¼³ðÈË
        if atkIsPlayer:
            
            gameFB.SetPlayerGameFBDict(tagPlayerID, FBPlayerDict_EnemyID, playerID)
            if tagPlayerID == gameFB.GetPlayerGameFBDictByKey(playerID, FBPlayerDict_EnemyID):
                #»÷ɱ³ðÈ˹㲥
                PlayerControl.NotifyCode(atkobj, 'AncientBattlefield_8')
                gameFB.SetPlayerGameFBDict(playerID, FBPlayerDict_EnemyID, 0)
                addScore += IpyGameDataPY.GetFuncCfg('ElderBattlefieldPoint', 2)
            if tagPlayerID == GameWorld.GetGameWorld().GetGameWorldDictByKey(Map_ElderBattlefield_TopPlayer):
                addScore += IpyGameDataPY.GetFuncCfg('ElderBattlefieldPoint', 1)
            
    if atkIsPlayer:
        updScore = __AddElderBattlefieldPlayerScore(atkobj, gameFB, addScore)
        GameWorld.DebugLog("»÷ɱÍæ¼Ò: »÷ɱ=%s,Á¬É±=%s,tagPlayerID=%s,updScore=%s" 
                               % (killCnt, contKillCntEx, tagPlayerID, updScore), playerID)
        DoFBHelp(atkobj, tick)
    if defender.GetGameObjType() == IPY_GameWorld.gotPlayer:
        DoFBHelp(defender, tick)
    return True


## Ö´Ðи±±¾É±¹ÖÂß¼­
#  @param curPlayer ɱ¹ÖµÄÈË
#  @param curNPC ±»É±µÄ¹Ö
#  @param tick µ±Ç°Ê±¼ä
#  @return None
def DoFB_Player_KillNPC(curPlayer, curNPC, tick):
    gameFB = GameWorld.GetGameFB()
    fbStep = gameFB.GetFBStep()
#    if fbStep != FB_State_Fight:
#        return
    if curNPC.GetNPCID() in IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldRobot', 2, {}).values():
        DoFBOnKill_Player(curPlayer, curNPC, tick)
        __OnRobotDie(tick)
    npcid = curNPC.GetNPCID()
    killNPCScoreDict = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldCfg', 1)
    addScore = killNPCScoreDict.get(npcid)
    if not addScore:
        return
    __AddElderBattlefieldPlayerScore(curPlayer, gameFB, addScore)
    DoFBHelp(curPlayer, tick)
    return

def DoFB_Npc_KillNPC(attacker, curNPC, tick):
    if curNPC.GetNPCID() in IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldRobot', 2, {}).values():
        __OnRobotDie(tick)
    return

def __OnRobotDie(tick):
    #¼Ç¼»úÆ÷ÈËËÀÍöʱ¼ä
    lineID = GameWorld.GetGameWorld().GetLineID()
    if lineID in PyGameData.g_elderBattleRobotDieDict:
        PyGameData.g_elderBattleRobotDieDict[lineID].append(tick)
    else:
        PyGameData.g_elderBattleRobotDieDict[lineID] = [tick]
    return

def OnMoveTouchNPC(curPlayer, curNPC, tick):
    #### ´¥ÅöNPC´¦ÀíÂß¼­
    npcid = curNPC.GetNPCID()
    buffNPCID = IpyGameDataPY.GetFuncCfg('ElderBattlefieldBuff', 2)
    if npcid != buffNPCID:
        return
    buffIDList = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldBuff')
    for buffID in buffIDList:
        #GameWorld.DebugLog('´¥ÅöNPC´¦ÀíÂß¼­ DelBuffBySkillID=%s'%buffID)
        BuffSkill.DelBuffBySkillID(curPlayer, buffID, tick)
    addBuffID = random.choice(buffIDList)
    #GameWorld.DebugLog('´¥ÅöNPC´¦ÀíÂß¼­ addBuffID=%s'%addBuffID)
    curSkill = GameWorld.GetGameData().GetSkillBySkillID(addBuffID)
    SkillShell.__DoLogic_AddBuff(curPlayer, curPlayer, curSkill, False, tick, 0, 0)
    #SkillCommon.AddBuffBySkillType(curPlayer, addBuffID, tick)
    return


#¹ØϵÓÐ3²ã£¬ÎÞ-ÓѺÃ-µÐÈË
##ÅжÏÊÇ·ñÓѺùØϵ£¬¸Ã²ãÅж¨ÎªÓѺÃÂß¼­ÖеÄ×îºóÅжÏ
# @param curPlayer Íæ¼ÒʵÀý
# @param curTagPlayer Ä¿±êÍæ¼ÒʵÀý
# @return ²¼¶ûÖµ
def CheckPlayersRelation_IsFriend(curPlayer, curTagPlayer):
    return not CanAttackPlayer(curPlayer, curTagPlayer)


##¸±±¾ÖÐ,¹¥»÷¶ÓÓÑÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @param curTagPlayer Ä¿±êÍæ¼ÒʵÀý
# @return ²¼¶ûÖµ
# @remarks
def DoCanAttackTeamer(curPlayer, curTagPlayer):
    return CanAttackPlayer(curPlayer, curTagPlayer)


##¸±±¾ÖÐ,ÊÇ·ñ¿É¹¥»÷
# @param curPlayer Íæ¼ÒʵÀý
# @param curTagPlayer Ä¿±êÍæ¼ÒʵÀý
# @return ²¼¶ûÖµ
# @remarks ¸±±¾ÖÐ,ÊÇ·ñ¿É¹¥»÷
def CanAttackPlayer(curPlayer, curTagPlayer):
    gameFB = GameWorld.GetGameFB()
    fbStep = gameFB.GetFBStep()
    
#    if fbStep != FB_State_Fight:
#        return False
    
    return True


## ÊÇ·ñ¸±±¾¸´»î
#  @param None
#  @return ÊÇ·ñ¸±±¾¸´»î
def OnPlayerReborn():
    return True


## ÖØÖø±±¾¸´»îÍæ¼Ò×ø±êµã
# @param None
# @return ÎÞÒâÒå
def OnResetFBRebornPlacePos(curPlayer, rebornPlace, tick):
    __SetPlayerRandomPos(curPlayer)
    #¸´»î¼Óbuff
    playerID = curPlayer.GetID()
    rebornBuffLV = GameWorld.GetGameFB().GetPlayerGameFBDictByKey(playerID, FBPlayerDict_RebornBuffLV)
    if rebornBuffLV >= IpyGameDataPY.GetFuncCfg('ElderBattlefieldRobot', 4):
        return
    __DoAddRebornBuff(curPlayer, rebornBuffLV+1, tick)
    return

def __DoAddRebornBuff(curPlayer, rebornBuffLV, tick):
    skillBuffID = IpyGameDataPY.GetFuncCfg('ElderBattlefieldRobot', 3) + rebornBuffLV - 1
    skillBuff = GameWorld.GetGameData().GetSkillBySkillID(skillBuffID)
    if not skillBuff:
        GameWorld.Log("ÉϹŸ´»î¼Óbuff   ÕÒ²»µ½¼¼ÄÜ%s" % skillBuffID)
        return
    playerID = curPlayer.GetID()
    GameWorld.GetGameFB().SetPlayerGameFBDict(playerID, FBPlayerDict_RebornBuffLV, rebornBuffLV)
    buffType = SkillCommon.GetBuffType(skillBuff)
    BuffSkill.DoAddBuff(curPlayer, buffType, skillBuff, tick)
    return

## ÉèÖÃÍæ¼ÒËæ»ú×ø±êµã
def __SetPlayerRandomPos(curPlayer):
    posX, posY = __GetRandPos()
    curPlayer.ResetPos(posX, posY)
    return


## »ñÈ¡¸±±¾Ïß·×î´óÍæ¼ÒÈËÊý
#  @param None
#  @return 
def GetFBLineMaxPlayerCount(lineID):
    cfg = IpyGameDataPY.GetFuncEvalCfg('ElderBattlefieldCfg', 3, {}).get(lineID)
    if not cfg:
        return 20
    return cfg[Def_PlayerCnt]

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