#!/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 PlayerTongTianLing
import PlayerGubao

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)
            PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_ElderBattlefield, 1)
            PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_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, 0, [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 OnRandomRobotJob(curNPC, lineRobotJobDict):
    ## Ëæ»ú»úÆ÷ÈËÖ°Òµ
    tick = GameWorld.GetGameWorld().GetTick()
    playerManager = GameWorld.GetMapCopyPlayerManager()
    for index in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(index)
        if not curPlayer:
            continue
        DoFBHelp(curPlayer, tick)
    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]

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